📄 0060.htm
字号:
<html>
<head>
<title>新时代软件教程:操作系统 主页制作 服务器 设计软件 网络技术 编程语言 文字编辑</title>
<meta http-equiv="Content-Type" content="text/html; charset=gb2312">
<style>
<!--
body, table {font-size: 9pt; font-family: 宋体}
a {text-decoration:none}
a:hover {color: red;text-decoration:underline}
.1 {background-color: rgb(245,245,245)}
-->
</style>
</head>
<p align="center"><script src="../../1.js"></script></a>
<p align="center"><big><strong>第七章 Java的多线程</strong></big></p>
<div align="right">---（文/袁小春）</div>
<h4 align=center>7.1 多 线 程 的 概 念 </h4>
<p>多 线 程 编 程 的 含 义 是 你 可 将 程 序 任 务 分 成 几 个 并 行 的
子 任 务。 特 别 是 在 网 络 编 程 中， 你 会 发 现 很 多 功 能 是 可 以
并 发 执 行 的。 比 如 网 络 传 输 速 度 较 慢， 用 户 输 入 速 度 较 慢，
你 可 以 用 两 个 独 立 的 线 程 去 完 成 这 ?copy; 功 能， 而 不 影 响
正 常 的 显 示 或 其 他 功 能。 多 线 程 是 与 单 线 程 比 较 而 言 的，
普 通 的WINDOWS采 用 单 线 程 程 序 结 构， 其 工 作 原 理 是： 主 程 序
有 一 个 消 息 循 环， 不 断 从 消 息 队 列 中 读 入 消 息 来 决 定 下
一 步 所 要 干 的 事 情， 一 般 是 一 个 子 函 数， 只 有 等 这 个 子 函
数 执 行 完 返 回 后， 主 程 序 才 能 接 收 另 外 的 消 息 来 执 行。 比
如 子 函 数 功 能 是 在 读 一 个 网 络 数 据， 或 读 一 个 文 件， 只 有
等 读 完 这 ?copy; 数 据 或 文 件 才 能 接 收 下 一 个 消 息。 在 执 行
这 个 子 函 数 过 程 中 你 什 么 也 不 能 干。 但 往 往 读 网 络 数 据
和 等 待 用 户 输 入 有 很 多 时 间 处 于 等 待 状 态， 多 线 程 利 用
这 个 特 点 将 任 务 分 成 多 个 并 发 任 务 后， 就 可 以 解 决 这 个
问 题。 </p>
<h4 align=center>7.1.1 Java线 程 的 模 型 </h4>
<p>Java的 设 计 思 想 是 建 立 在 当 前 大 多 数 操 作 系 统 都 实 现 了
线 程 调 度。Java虚 拟 机 的 很 多 任 务 都 依 赖 线 程 调 度， 而 且 所
有 的 类 库 都 是 为 多 线 程 设 计 的。 实 时 上，Java支 持Macintosh和Ms-dos
的 平 台 ?reg; 所 以 迟 迟 未 出 来 就 是 因 为 这 两 个 平 台 都 不 支
持 多 线 程。Java利 用 多 线 程 实 现 了 整 个 执 行 环 境 是 异 步 的。
在Java程 序 里 没 有 主 消 息 循 环。 如 果 一 个 线 程 等 待 读 取 网
络 数 据， 它 可 以 运 行 但 不 停 止 系 统 的 其 他 线 程 执 行。 用 于
处 理 用 户 输 入 的 线 程 大 多 时 间 是 等 待 用 户 敲 键 盘 或 击 鼠
标。 你 还 可 以 使 动 画 的 每 一 帧 ?reg; 间 停 顿 一 秒 而 并 不 使
系 统 暂 停。 一 ?copy; 线 程 启 动 后， 它 可 以 被 挂 起， 暂 时 不
让 它 执 行。 挂 起 的 线 程 可 以 重 新 恢 复 执 行。 任 何 时 间 线 程
都 可 以 被 停 止， 被 停 止 的 线 程 就 不 能 再 重 新 启 动。 Java语
言 里， 线 程 表 现 为 线 程 类， 线 程 类 封 装 了 所 有 需 要 的 线 程
操 作 控 制。 在 你 心 里， 必 须 很 清 晰 地 区 分 开 线 程 对 象 和 运
行 线 程， 你 可 以 将 线 程 对 象 看 作 是 运 行 线 程 的 控 制 面 板。
在 线 程 对 象 里 有 很 多 函 数 来 控 制 一 个 线 程 是 否 运 行， 睡
眠， 挂 起 或 停 止。 线 程 类 是 控 制 线 程 行 为 的 唯 一 的 手 段。
一 ?copy; 一 个Java程 序 启 动 后， 就 已 经 有 一 个 线 程 在 运 行。
你 可 通 过 调 用Thread.currentThread 函 数 来 查 看 当 前 运 行 的 是
哪 一 个 线 程。 一 ?copy; 你 得 到 一 个 线 程 的 控 制 柄， 你 就 可
以 作 一 ?copy; 很 有 趣 的 事 情， 即 使 单 线 程 也 一 样。 下 面 这
个 例 子 让 你 知 道 怎 样 操 纵 当 前 线 程。 Filename:testthread </p>
<p>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);
} </p>
<p>} catch (InterruptedException e) {System.out.println("thread has
wrong"); } </p>
<p>} } </p>
<p>执 行 结 果：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 </p>
<h4 align=center>7.1.2 启 动 接 口</h4>
<p>一 个 线 程 并 不 激 动 人 心， 多 个 线 程 才 有 实 际 意 义。 我 们
怎 样 创 建 更 多 的 线 程 呢？ 我 们 需 要 创 建 线 程 类 的 另 一 个
实 例。 当 我 们 构 造 了 线 程 类 的 一 个 新 的 实 例， 我 们 必 须 告
诉 它 在 新 的 线 程 里 应 执 行 哪 一 段 程 序。 你 可 以 在 任 意 实
现 了 启 动 接 口 的 对 象 上 启 动 一 个 线 程。 启 动 接 口 是 一 个
抽 象 接 口， 来 表 示 本 对 象 有 一 ?copy; 函 数 想 异 步 执 行。 要
实 现 启 动 接 口， 一 个 类 只 需 要 有 一 个 叫run的 函 数。 下 面 是
创 建 一 个 新 线 程 的 例 子： </p>
<p>Filename:twothread.java </p>
<p>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); } </p>
<p>} catch (InterruptedException e) {System.out.println("thread has
wrong"); } </p>
<p>System.out.println("second thread exit"); } public static
void main(String args[]) { new twothread(); } } </p>
<p>执 行 结 果：java twothread </p>
<p>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 </p>
<p>main线 程 用new Thread(this, "the second thread")创 建 了
一 个Thread对 象， 通 过 传 递 第 一 个 参 数 来 标 明 新 线 程 来 调 用this对
象 的run函 数。 然 后 我 们 调 用start函 数， 它 将 使 线 程 从run函 数
开 始 执 行。 </p>
<h4 align=center>7.1.3 同 步 </h4>
<p>因 为 多 线 程 给 你 提 ?copy; 了 程 序 的 异 步 执 行 的 功 能， 所
以 在 必 要 时 必 须 还 提 ?copy; 一 种 同 步 机 制。 例 如， 你 想 两
个 线 程 通 讯 并 共 享 一 个 复 杂 的 数 据 结 构， 你 需 要 一 种 机
制 让 他 们 相 互 牵 制 并 正 确 执 行。 为 这 个 目 的，Java用 一 种 叫
监 视 器(monitor)的 机 制 实 现 了 进 程 间 的 异 步 执 行。 可 以 将 监
视 器 看 作 是 一 个 很 小 的 盒 子， 它 只 能 容 纳 一 个 线 程。 一 ?copy;
一 个 线 程 进 入 一 个 监 视 器， 所 有 其 他 线 程 必 须 等 到 第 一
个 线 程 退 出 监 视 器 后 才 能 进 入。 这 ?copy; 监 视 器 可 以 设 计
成 保 护 共 享 的 数 据 不 被 多 个 线 程 同 时 操 作。 大 多 数 多 线
程 系 统 将 这 ?copy; 监 视 器 设 计 成 对 象，Java提 ?copy; 了 一 种
更 清 晰 的 解 决 方 案。 没 有Monitor类； 每 个 对 象 通 过 将 他 们 的
成 员 函 数 定 义 成synchronized来 定 义 自 己 的 显 式 监 视 器， 一 ?copy;
一 个 线 程 执 行 在 一 个synchronized函 数 里， 其 他 任 何 线 程 都 不
能 调 用 同 一 个 对 象 的 synchronized函 数。 </p>
<h4 align=center>7.1.4 消 息 </h4>
<p>一 ?copy; 你 的 程 序 被 分 成 几 个 逻 辑 线 程， 你 必 须 清 晰 的
知 道 这 ?copy; 线 程 ?reg; 间 应 怎 样 相 互 通 讯。Java 提 ?copy;
了wait和notify等 功 能 来 使 线 程 ?reg; 间 相 互 交 谈。 一 个 线 程
可 以 进 入 某 一 个 对 象 的synchronized 函 数 进 入 等 待 状 态， 直
到 其 他 线 程 显 式 地 将 它 唤 醒。 可 以 有 多 个 线 程 进 入 同 一
个 函 数 并 等 待 同 一 个 唤 醒 消 息。 </p>
<h4 align=center>7.2 Java线 程 例 子 </h4>
<h4 align=center>7.2.1 显 式 定 义 线 程 </h4>
<p>在 我 们 的 单 线 程 应 用 程 序 里， 我 们 并 没 有 看 见 线 程， 因
为Java能 自 动 创 建 和 控 制 你 的 线 程。 如 果 你 使 用 了 理 解Java语
言 的 浏 览 器， 你 就 已 经 看 到 使 用 多 线 程 的Java程 序 了。 你 也
许 注 意 到 两 个 小 程 序 可 以 同 时 运 行， 或 在 你 移 动 滚 动 条
时 小 程 序 继 续 执 行。 这 并 不 是 表 明 小 程 序 是 多 线 程 的， 但
说 明 这 个 浏 览 器 是 多 线 程 的。 多 线 程 应 用 程 序(或applet)可
以 使 用 好 几 个 执 行 上 下 文 来 完 成 它 们 的 工 作。 多 线 程 利
用 了 很 多 任 务 包 含 单 独 的 可 分 离 的 子 任 务 的 特 点。 每 一
个 线 程 完 成 一 个 子 任 务。 </p>
<p>但 是， 每 一 个 线 程 完 成 子 任 务 时 还 是 顺 序 执 行 的。 一 个
多 线 程 程 序 允 许 各 个 线 程尽快 执 行 完 它 们。 这 种 特 点 会 有
更 好 的 实 时 输 入 反 应。 </p>
<h4 align=center>7.2.2 多 线 程 例 子</h4>
<p>下 面 这 个 例 子 创 建 了 三 个 单 独 的 线 程， 它 们 分 别 打 印
自 己 的“Hello World": </p>
<p>//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; </p>
<p>//Our constructor to store the name (whoami) //and time to sleep (delay)
public TestThread(String s, int d) { whoami = s; delay = d; } </p>
<p>//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));
</p>
<p>//Start each of the threads t1.start(); t2.start(); t3.start(); } }
</p>
<h4 align=center>7.2.3 启 动 一 个 线 程 </h4>
<p>程 序 启 动 时 总 是 调 用main()函 数， 因 此main()是 我 们 创 建 和
启 动 线 程 的 地 方： </p>
<p>t1 = new TestThread("Thread1",(int)(Math.readom()*2000));
</p>
<p>这 一 行 创 建 了 一 个 新 的 线 程。 后 面 的 两 个 参 数 传 递 了
线 程 的 名 称 和 线 程 在 打 印 信 息 ?reg; 前 的 延 时 时 间。 因 为
我 们 直 接 控 制 线 程， 我 们 必 须 直 接 启 动 它： t1.start(); </p>
<h4 align=center>7.2.4 操 作 线 程 </h4>
<p>如 果 创 建 线 程 正 常，t1应 包 含 一 个 有 效 的 执 行 线 程。 我
们 在 线 程 的run()函 数 里 控 制 线 程。 一 ?copy; 我 们 进 入run()函
数， 我 们 便 可 执 行 里 面 的 任 何 程 序。run()好 象main()一 样。 一
?copy;run() 执 行 完， 这 个 线 程 也 就 结 束 了。 在 这 个 例 子 里，
我 们 试 着 延 迟 一 个 随 机 的 时 间（通 过 参 数 传 递?copy;： sleep(delay);
</p>
<p>sleep()函 数 只 是 简 单 地 告 诉 线 程 休 息 多 少 个 毫 秒 时 间。
如 果 你 想 推 迟 一 个 线 程 的 执 行， 你 应 使 用sleep()函 数。 当 线
程 睡 眠 是sleep()并 不 占 用 系 统 资 源。 其 它 线 程 可 继 续 工 作。
一 ?copy; 延 迟 时 间 完 毕， 它 将 打 印"Hello World"和 线
程 名 称 及 延 迟 时 间。 </p>
<h4 align=center>7.2.5 暂 停 一 个 线 程 </h4>
<p>我 们 经 常 需 要 挂 起 一 个 线 程 而 不 指 定 多 少 时 间。 例 如，
⌨️ 快捷键说明
复制代码
Ctrl + C
搜索代码
Ctrl + F
全屏模式
F11
切换主题
Ctrl + Shift + D
显示快捷键
?
增大字号
Ctrl + =
减小字号
Ctrl + -