第七章 Java的多线程
7.1 多 线 程 的 概 念
多 线 程 编 程 的 含 义 是 你 可 将 程 序 任 务 分 成 几 个 并 行 的子 任 务。 特 别 是 在 网 络 编 程 中， 你 会 发 现 很 多 功 能 是 可 以并 发 执 行 的。 比 如 网 络 传 输 速 度 较 慢， 用 户 输 入 速 度 较 慢，你 可 以 用 两 个 独 立 的 线 程 去 完 成 这 ?copy; 功 能， 而 不 影 响正 常 的 显 示 或 其 他 功 能。 多 线 程 是 与 单 线 程 比 较 而 言 的，普 通 的WINDOWS采 用 单 线 程 程 序 结 构， 其 工 作 原 理 是： 主 程 序有 一 个 消 息 循 环， 不 断 从 消 息 队 列 中 读 入 消 息 来 决 定 下一 步 所 要 干 的 事 情， 一 般 是 一 个 子 函 数， 只 有 等 这 个 子 函数 执 行 完 返 回 后， 主 程 序 才 能 接 收 另 外 的 消 息 来 执 行。 比如 子 函 数 功 能 是 在 读 一 个 网 络 数 据， 或 读 一 个 文 件， 只 有等 读 完 这 ?copy; 数 据 或 文 件 才 能 接 收 下 一 个 消 息。 在 执 行这 个 子 函 数 过 程 中 你 什 么 也 不 能 干。 但 往 往 读 网 络 数 据和 等 待 用 户 输 入 有 很 多 时 间 处 于 等 待 状 态， 多 线 程 利 用这 个 特 点 将 任 务 分 成 多 个 并 发 任 务 后， 就 可 以 解 决 这 个问 题。
7.1.1 Java线 程 的 模 型
Java的 设 计 思 想 是 建 立 在 当 前 大 多 数 操 作 系 统 都 实 现 了线 程 调 度。Java虚 拟 机 的 很 多 任 务 都 依 赖 线 程 调 度， 而 且 所有 的 类 库 都 是 为 多 线 程 设 计 的。 实 时 上，Java支 持Macintosh和Ms-dos 的 平 台 ?reg; 所 以 迟 迟 未 出 来 就 是 因 为 这 两 个 平 台 都 不 支持 多 线 程。Java利 用 多 线 程 实 现 了 整 个 执 行 环 境 是 异 步 的。在Java程 序 里 没 有 主 消 息 循 环。 如 果 一 个 线 程 等 待 读 取 网络 数 据， 它 可 以 运 行 但 不 停 止 系 统 的 其 他 线 程 执 行。 用 于处 理 用 户 输 入 的 线 程 大 多 时 间 是 等 待 用 户 敲 键 盘 或 击 鼠标。 你 还 可 以 使 动 画 的 每 一 帧 ?reg; 间 停 顿 一 秒 而 并 不 使系 统 暂 停。 一 ?copy; 线 程 启 动 后， 它 可 以 被 挂 起， 暂 时 不让 它 执 行。 挂 起 的 线 程 可 以 重 新 恢 复 执 行。 任 何 时 间 线 程都 可 以 被 停 止， 被 停 止 的 线 程 就 不 能 再 重 新 启 动。 Java语言 里， 线 程 表 现 为 线 程 类， 线 程 类 封 装 了 所 有 需 要 的 线 程操 作 控 制。 在 你 心 里， 必 须 很 清 晰 地 区 分 开 线 程 对 象 和 运行 线 程， 你 可 以 将 线 程 对 象 看 作 是 运 行 线 程 的 控 制 面 板。在 线 程 对 象 里 有 很 多 函 数 来 控 制 一 个 线 程 是 否 运 行， 睡眠， 挂 起 或 停 止。 线 程 类 是 控 制 线 程 行 为 的 唯 一 的 手 段。一 ?copy; 一 个Java程 序 启 动 后， 就 已 经 有 一 个 线 程 在 运 行。你 可 通 过 调 用Thread.currentThread 函 数 来 查 看 当 前 运 行 的 是哪 一 个 线 程。 一 ?copy; 你 得 到 一 个 线 程 的 控 制 柄， 你 就 可以 作 一 ?copy; 很 有 趣 的 事 情， 即 使 单 线 程 也 一 样。 下 面 这个 例 子 让 你 知 道 怎 样 操 纵 当 前 线 程。 Filename:testthread
class testthread { public static void main(String args[]) { Thread t =Thread.currentThread(); t.setName("This Thread is running"); System.out.println("The running thread:" + t); try { for (int i=0;i<5;i++) { System.out.println("Sleep time "+i); Thread.sleep(1000); }
} catch (InterruptedException e) {System.out.println("thread has wrong"); }
} }
执 行 结 果：java testthread The running thread:Thread[This Thread is running,5,main] Sleep time 0 Sleep time 1 Sleep time 2 Sleep time 3 Sleep time 4
7.1.2 启 动 接 口
一 个 线 程 并 不 激 动 人 心， 多 个 线 程 才 有 实 际 意 义。 我 们怎 样 创 建 更 多 的 线 程 呢？ 我 们 需 要 创 建 线 程 类 的 另 一 个实 例。 当 我 们 构 造 了 线 程 类 的 一 个 新 的 实 例， 我 们 必 须 告诉 它 在 新 的 线 程 里 应 执 行 哪 一 段 程 序。 你 可 以 在 任 意 实现 了 启 动 接 口 的 对 象 上 启 动 一 个 线 程。 启 动 接 口 是 一 个抽 象 接 口， 来 表 示 本 对 象 有 一 ?copy; 函 数 想 异 步 执 行。 要实 现 启 动 接 口， 一 个 类 只 需 要 有 一 个 叫run的 函 数。 下 面 是创 建 一 个 新 线 程 的 例 子：
Filename:twothread.java
class twothread implements Runnable { twothread() { Thread t1 =Thread.currentThread(); t1.setName("The first main thread"); System.out.println("The running thread:" + t1); Thread t2 = new Thread(this,"the second thread"); System.out.println("creat another thread"); t2.start(); try { System.out.println("first thread will sleep"); Thread.sleep(3000); }catch (InterruptedException e) {System.out.println("first thread has wrong"); } System.out.println("first thread exit"); } public void run() { try { for (int i=0;i<5;i++) { System.out.println("Sleep time for thread 2:"+i); Thread.sleep(1000); }
} catch (InterruptedException e) {System.out.println("thread has wrong"); }
System.out.println("second thread exit"); } public static void main(String args[]) { new twothread(); } }
执 行 结 果：java twothread
The running thread:Thread[The first main thread,5,main] creat another thread first thread will sleep Sleep time for thread 2:0 Sleep time for thread 2:1 Sleep time for thread 2:2 first thread exit Sleep time for thread 2:3 Sleep time for thread 2:4 second thread exit
main线 程 用new Thread(this, "the second thread")创 建 了一 个Thread对 象， 通 过 传 递 第 一 个 参 数 来 标 明 新 线 程 来 调 用this对象 的run函 数。 然 后 我 们 调 用start函 数， 它 将 使 线 程 从run函 数开 始 执 行。
7.1.3 同 步
因 为 多 线 程 给 你 提 ?copy; 了 程 序 的 异 步 执 行 的 功 能， 所以 在 必 要 时 必 须 还 提 ?copy; 一 种 同 步 机 制。 例 如， 你 想 两个 线 程 通 讯 并 共 享 一 个 复 杂 的 数 据 结 构， 你 需 要 一 种 机制 让 他 们 相 互 牵 制 并 正 确 执 行。 为 这 个 目 的，Java用 一 种 叫监 视 器(monitor)的 机 制 实 现 了 进 程 间 的 异 步 执 行。 可 以 将 监视 器 看 作 是 一 个 很 小 的 盒 子， 它 只 能 容 纳 一 个 线 程。 一 ?copy; 一 个 线 程 进 入 一 个 监 视 器， 所 有 其 他 线 程 必 须 等 到 第 一个 线 程 退 出 监 视 器 后 才 能 进 入。 这 ?copy; 监 视 器 可 以 设 计成 保 护 共 享 的 数 据 不 被 多 个 线 程 同 时 操 作。 大 多 数 多 线程 系 统 将 这 ?copy; 监 视 器 设 计 成 对 象，Java提 ?copy; 了 一 种更 清 晰 的 解 决 方 案。 没 有Monitor类； 每 个 对 象 通 过 将 他 们 的成 员 函 数 定 义 成synchronized来 定 义 自 己 的 显 式 监 视 器， 一 ?copy; 一 个 线 程 执 行 在 一 个synchronized函 数 里， 其 他 任 何 线 程 都 不能 调 用 同 一 个 对 象 的 synchronized函 数。
7.1.4 消 息
一 ?copy; 你 的 程 序 被 分 成 几 个 逻 辑 线 程， 你 必 须 清 晰 的知 道 这 ?copy; 线 程 ?reg; 间 应 怎 样 相 互 通 讯。Java 提 ?copy; 了wait和notify等 功 能 来 使 线 程 ?reg; 间 相 互 交 谈。 一 个 线 程可 以 进 入 某 一 个 对 象 的synchronized 函 数 进 入 等 待 状 态， 直到 其 他 线 程 显 式 地 将 它 唤 醒。 可 以 有 多 个 线 程 进 入 同 一个 函 数 并 等 待 同 一 个 唤 醒 消 息。
7.2 Java线 程 例 子
7.2.1 显 式 定 义 线 程
在 我 们 的 单 线 程 应 用 程 序 里， 我 们 并 没 有 看 见 线 程， 因为Java能 自 动 创 建 和 控 制 你 的 线 程。 如 果 你 使 用 了 理 解Java语言 的 浏 览 器， 你 就 已 经 看 到 使 用 多 线 程 的Java程 序 了。 你 也许 注 意 到 两 个 小 程 序 可 以 同 时 运 行， 或 在 你 移 动 滚 动 条时 小 程 序 继 续 执 行。 这 并 不 是 表 明 小 程 序 是 多 线 程 的， 但说 明 这 个 浏 览 器 是 多 线 程 的。 多 线 程 应 用 程 序(或applet)可以 使 用 好 几 个 执 行 上 下 文 来 完 成 它 们 的 工 作。 多 线 程 利用 了 很 多 任 务 包 含 单 独 的 可 分 离 的 子 任 务 的 特 点。 每 一个 线 程 完 成 一 个 子 任 务。
但 是， 每 一 个 线 程 完 成 子 任 务 时 还 是 顺 序 执 行 的。 一 个多 线 程 程 序 允 许 各 个 线 程尽快 执 行 完 它 们。 这 种 特 点 会 有更 好 的 实 时 输 入 反 应。
7.2.2 多 线 程 例 子
下 面 这 个 例 子 创 建 了 三 个 单 独 的 线 程， 它 们 分 别 打 印自 己 的“Hello World":
//Define our simple threads.They will pause for a short time //and then print out their names and delay times class TestThread extends Thread { private String whoami; private int delay;
//Our constructor to store the name (whoami) //and time to sleep (delay) public TestThread(String s, int d) { whoami = s; delay = d; }
//Run - the thread method similar to main() //When run is finished, the thread dies. //Run is called from the start() method of Thread public void run() { //Try to sleep for the specified time try { sleep(delay); } catch(InterruptedException e) {} //Now print out our name System.out.println("Hello World!"+whoami+""+delay); } } /** * Multimtest. A simple multithread thest program */ public class multitest { public static void main(String args[]) { TestThread t1,t2,t3; //Create our test threads t1 = new TestThread("Thread1",(int)(Math.readom()*2000)); t2 = new TestThread("Thread2",(int)(Math.readom()*2000)); t3 = new TestThread("Thread3",(int)(Math.readom()*2000));
//Start each of the threads t1.start(); t2.start(); t3.start(); } }
7.2.3 启 动 一 个 线 程
程 序 启 动 时 总 是 调 用main()函 数， 因 此main()是 我 们 创 建 和启 动 线 程 的 地 方：
t1 = new TestThread("Thread1",(int)(Math.readom()*2000));
这 一 行 创 建 了 一 个 新 的 线 程。 后 面 的 两 个 参 数 传 递 了线 程 的 名 称 和 线 程 在 打 印 信 息 ?reg; 前 的 延 时 时 间。 因 为我 们 直 接 控 制 线 程， 我 们 必 须 直 接 启 动 它： t1.start();
7.2.4 操 作 线 程
如 果 创 建 线 程 正 常，t1应 包 含 一 个 有 效 的 执 行 线 程。 我们 在 线 程 的run()函 数 里 控 制 线 程。 一 ?copy; 我 们 进 入run()函数， 我 们 便 可 执 行 里 面 的 任 何 程 序。run()好 象main()一 样。 一 ?copy;run() 执 行 完， 这 个 线 程 也 就 结 束 了。 在 这 个 例 子 里，我 们 试 着 延 迟 一 个 随 机 的 时 间（通 过 参 数 传 递?copy;： sleep(delay);
sleep()函 数 只 是 简 单 地 告 诉 线 程 休 息 多 少 个 毫 秒 时 间。如 果 你 想 推 迟 一 个 线 程 的 执 行， 你 应 使 用sleep()函 数。 当 线程 睡 眠 是sleep()并 不 占 用 系 统 资 源。 其 它 线 程 可 继 续 工 作。一 ?copy; 延 迟 时 间 完 毕， 它 将 打 印"Hello World"和 线程 名 称 及 延 迟 时 间。
7.2.5 暂 停 一 个 线 程
我 们 经 常 需 要 挂 起 一 个 线 程 而 不 指 定 多 少 时 间。 例 如，如 果 你 创 建 了 一 个 含 有 动 画 线 程 的 小 程 序。 也 许 你 让 用户 暂 停 动 画 至 到 他 们 想 恢 复 为 止。 你 并 不 想 将 动 画 线 程仍 调， 但 想 让 它 停 止。 象 这 种 类 似 的 线 程 你 可 用suspend()函数 来 控 制： t1.suspend();
这 个 函 数 并 不 永 久 地 停 止 了 线 程， 你 还 可 用resume()函 数重 新 激 活 线 程： t1.resume();
7.2.6 停 止 一 个 线 程
线 程 的 最 后 一 个 控 制 是 停 止 函 数stop()。 我 们 用 它 来 停止 线 程 的 执 行： t1.stop();
注 意： 这 并 没 有 消 灭 这 个 线 程， 但 它 停 止 了 线 程 的 执 行。并 且 这 个 线 程 不 能 用t1.start()重 新 启 动。 在 我 们 的 例 子 里，我 们 从 来 不 用 显 式 地 停 止 一 个 线 程。 我 们 只 简 单 地 让 它执 行 完 而 已。 很 多 复 杂 的 线 程 例 子 将 需 要 我 们 控 制 每 一个 线 程。 在 这 种 情 况 下 会 使 用 到stop()函 数。 如 果 需 要， 你可 以 测 试 你 的 线 程 是 否 被 激 活。 一 个 线 程 已 经 启 动 而 且没 有 停 止 被 认 为 是 激 活 的。 t1.isAlive() 如 果t1是 激 活 的， 这个 函 数 将 返 回true.
7.2.7 动 画 例 子
下 面 是 一 个 包 含 动 画 线 程 的applet例 子：
import java.awt.*; import java.awt.image.ImageProducer; import java.applet.Applet;
public class atest3 extends Applet implements Runnable { Image images[]; MediaTracker tracker; int index = 0; Thread animator;
int maxWidth,maxHeight; //Our off-screen components for double buffering. Image offScrImage; Graphics offScrGC;
//Can we paint yes? boolean loaded = false;
//Initialize the applet. Set our size and load the images public void init() [ //Set up our image monitor tracker = new MediaTracker(this);
//Set the size and width of our applet maxWidth = 100; maxHeight =100;
images = new Image[10]; //Set up the double-buffer and resize our applet try { offScrImage = createImage(maxWidth,maxHeight); offScrGC = offScrImage.getGraphics(); offScrGC.setColor(Color.lightGray); offScrGC.fillRect(0,0,maxWidth,maxHeight); resize(maxWidth,maxHeight); }catch (Exception e) { e.printStackTrace(); }
//load the animation images into an array for (int i=0;i<10;i++) { String imageFile = new String ("images/Duke/T" +String.valueOf(i+1) +".gif"); images[i] = getImage(getDocumentBase(),imageFile): //Register this image with the tracker tracker.addImage(images[i],i); } try { //Use tracker to make sure all the images are loaded tracker.waitForAll(); } catch (InterruptedException e) {} loaded = true; }
//Paint the current frame. public void paint (Graphics g) { if (loaded) { g.drawImage(offScrImage,0,0,this); } }
//Start ,setup our first image public void start() { if (tracker.checkID (index)) { offScrGC.drawImage (images[index],0,0,this); } animator = new Thread(this); animator.start(); }
//Run,do the animation work here. //Grab an image, pause ,grab the next... public void run() { //Get the id of the current thread Thread me = Thread.currentThread();
//If our animator thread exist,and is the current thread... while ((animatr!= null) && (animator==me)) { if ( tracker.checkID (index)) { //Clear the background and get the next image offScrGC.fillRect(0,0,100,100); offScrGCdrawImage(images[index],0,0,this); index++; //Loop back to the beginning and keep going if (index>= images.length) { index = 0; } } //Delay here so animation looks normal try { animator.sleep(200); }catch (InterruptedException e) {} //Draw the next frame repaint(); } } }
7.3 多 线 程 ?reg; 间 的 通 讯
7.3.1 生 产 者 和 消 费 者
多 线 程 的 一 个 重 要 特 点 是 它 们 ?reg; 间 可 以 互 相 通 讯。你 可 以 设 计 线 程 使 用 公 用 对 象， 每 个 线 程 都 可 以 独 立 操作 公 用 对 象。 典 型 的 线 程 间 通 讯 建 立 在 生 产 者 和 消 费 者模 型 上： 一 个 线 程 产 生 输 出； 另 一 个 线 程 使 用 输 入。
buffer
让 我 们 创 建 一 个 简 单 的"Alphabet Soup"生 产 者 和 相应 的 消 费 者.
7.3.2 生 产 者
生 产 者 将 从thread类 里 派 生： class Producer extends Thread { private Soup soup; private String alphabet = " ABCDEFGHIJKLMNOPQRSTUVWXYZ";
public Producer(Soup s) { //Keep our own copy of the shared object soup = s; }
public void run() { char c; //Throw 10 letters into the soup for (int i=0;i<10;i++) { c = alphabet.charAt((int)(Math.random() *26)); soup.add(c); //print a record of osr addition System.out.println("Added"+c + "to the soup."); //wait a bit before we add the next letter try { sleep((int)(Math.random() *1000)); } catch (InterruptedException e) {} } } }
注 意 我 们 创 建 了Soup类 的 一 个 实 例。 生 产 者 用soup.add()函数 来 建 立 字 符 池。
7.3.3 消 费 者
让 我 们 看 看 消 费 者 的 程 序： class Consumer extends Thread { private Soup soup;
public Consumer (Soup s) { //keep our own copy of the shared object soup = s; }
public void run() { char c; //Eat 10 letters from the alphabet soup for (int I=0 ;i<10;i++) { //grab one letter c = soup.eat(); //Print out the letter that we retrieved System.out.println("Ate a letter: " +c); //try { sleep((int)(Math.raddom()*2000)); } catch (InterruptedException e) {} } } }
同 理， 象 生 产 者 一 样， 我 们 用soup.eat()来 处 理 信 息。 那 么，Soup类到 底 干 什 么 呢？
7.3.4 监 视
Soup类 执 行 监 视 两 个 线 程 ?reg; 间 传 输 信 息 的 功 能。 监 视是 多 线 程 中 不 可 缺 少 的 一 部 分， 因 为 它 保 持 了 通 讯 的 流 ?copy;。 让 我 们 看 看Soup.java文 件： class Soup { private char buffer[] = new char[6]; private int next = 0; //Flags to keep track of our buffer status private boolean isFull = false; private boolean isEmpty = true;
public syschronized char eat() { //We can't eat if there isn't anything in the buffer while (isEmpty == true) { try { wait() ;//we'll exit this when isEmpty turns false }catch (InterruptedException e) {} } //decrement the count,since we're going to eat one letter next--; //Did we eat the last letter? if (next== 0) { isEmpty = true; } //We know the buffer can't be full,because we just ate isFull = false; notify(); //return the letter to the thread that is eating return (buffer[next]); }
//method to add letters to the buffer public synchronized void add(char c) { //Wait around until there's room to add another letter while (isFull == true ) { try{ wait();//This will exit when isFull turns false }catch (InterruptedException e) {} } //add the letter to the next available spot buffer[next]=c; //Change the next available spot next++; //Are we full; if (next ==6) { isFull =true; } isEmpty =false; notify(); } }
soup类 包 含 两 个 重 要 特 征： 数 据 成 员buffer[]是 私 有 的， 功能 成 员add()和eat()是 公 有 的。
数 据 私 有 避 免 了 生 产 者 和 消 费 者 直 接 获 得 数 据。 直 接访 问 数 据 可 能 造 成 错 误。 例 如， 如 果 消 费 者 企 图 从 空 缓 冲区 里 取 出 数 据， 你 将 得 到 不 必 要 的 异 常， 否 则， 你 只 能 锁住 进 程。 同 步 访 问 方 法 避 免 了 破 坏 一 个 共 享 对 象。 当 生 产者 向soup里 加 入 一 个 字 母 时， 消 费 者 不 能 吃 字 符， 诸 如 此 类。这 种 同 步 是 维 持 共 享 对 象 完 整 性 的 重 要 方 面。notify()函 数将 唤 醒 每 一 个 等 待 线 程。 等 待 线 程 将 继 续 它 的 访 问。
7.3.5 联 系 起 来
现 在 我 们 有 一 个 生 产 者， 一 个 消 费 者 和 一 个 共 享 对 象，怎 样 实 现 它 们 的 交 互 呢？ 我 们 只 需 要 一 个 简 单 的 控 制 程序 来 启 动 所 有 的 线 程 并 确 信 每 一 个 线 程 都 是 访 问 的 同 一个 共 享 对 象。 下 面 是 控 制 程 序 的 代 码，SoupTest.java: class SoupTest { public static void main(String args[]) { Soup s = new Soup(); Producer p1 = new Producer(s); Consumer c1 = new Consumer(s);
p1.start(); c1.start(); } }
7.3.6 监 视 生 产 者
生 产 者/消 费 者 模 型 程 序 经 常 用 来 实 现 远 程 监 视 功 能，它 让 消 费 者 看 到 生 产 者 同 用 户 的 交 互 或 同 系 统 其 它 部 分的 交 互。 例 如， 在 网 络 中， 一 组 生 产 者 线 程 可 以 在 很 多 工作 站 上 运 行。 生 产 者 可 以 打 印 文 档， 文 档 打 印 后， 一 个 标志 将 保 存 下 来。 一 个（或 多 个?copy; 消 费 者 将 保 存 标 志 并 在晚 上 报 告 白 天 打 印 活 动 的 情 况。 另 外， 还 有 例 子 在 一 个 工作 站 是 分 出 几 个 独 立 的 窗 口。 一 个 窗 口 用 作 用 户 输 入（生产 者?copy;， 另 一 个 窗 口 作 出 对 输 入 的 反 应（消 费 者?copy;。
7.4 线 程API列 表
下 面 是 一 ?copy; 常 用 的 线 程 类 的 方 法 函 数 列 表：
类 函 数： 以 下 是Thread的 静 态 函 数， 即 可 以 直 接 从Thread类调 用。
currentThread 返 回 正 在 运 行 的Thread对 象 yield 停 止 运 行 当 前线 程， 让 系 统 运 行 下 一 个 线 程 sleep(int n) 让 当 前 线 程 睡 眠n毫秒
对 象 函 数： 以 下 函 数 必 须 用Thread的 实 例 对 象 来 调 用。
start start函 数 告 诉java运 行 系 统 为 本 线 程 建 立 一 个 执 行环 境， 然 后 调 用 本 线 程 的run()函 数。 run 是 运 行 本 线 程 的 将要 执 行 的 代 码， 也 是Runnable接 口 的 唯 一 函 数。 当 一 个 线 程初 始 化 后， 由start函 数 来 调 用 它， 一 ?copy;run函 数 返 回， 本线 程 也 就 终 止 了。 stop 让 某 线 程 马 上 终 止， 系 统 将 删 除 本线 程 的 执 行 环 境 suspend 与stop函 数 不 同，suspend将 线 程 暂 停 执行， 但 系 统 不 破 坏 线 程 的 执 行 环 境， 你 可 以 用resume来 恢 复本 线 程 的 执 行 resume 恢 复 被 挂 起 的 线 程 进 入 运 行 状 态 setPriority(int p) 给 线 程 设 置 优 先 级 getPriority 返 回 线 程 的 优 先 级 setName(String name) 给 线 程 设 置 名 称 getName 取 线 程 的 名 称
本 章 小 结：
1.多 线 程 是java语 言 的 重 要 特 点，java语 言 用Thread类 封 装 了线 程 的 所 有 操 作。 2.线 程 的 接 口 名 为Runnable 3.线 程 ?reg; 间同 步 机 制 为synchronized关 键 词 4.线 程 ?reg; 间 通 讯 靠wait与notify消息
