java8多线程课件2016-xh.pptx

《java8多线程课件2016-xh.pptx》由会员分享，可在线阅读，更多相关《java8多线程课件2016-xh.pptx（54页珍藏版）》请在装配图网上搜索。

1、第 八 章 多 线 程 机 制 8.1 Java多 线 程 机 制 （ 概 念 掌 握 ， 理 解 性 内容 ） 8 .2 多 线 程 的 实 现 方 法 （ 重 点 及 难 点 ） 8 .3 多 线 程 状 态 及 调 度 （ 重 点 ） 8 .4 线 程 同 步 8 .5 线 程 通 信 n1 8.1 Java多 线 程 机 制 8 .1 .1 线 程 的 基 本 概 念 线 程 的 概 念 ： 线 程 就 是 应 用 程 序 中 的 一 个可 执 行 线 索 ， 多 线 程 就 是 同 一 个 应 用 程 序中 有 多 个 可 执 行 线 索 ， 它 们 可 以 并 发 执 行 。 为

2、什 么 要 有 多 线 程 ？ 线 程 与 进 程 的 区 别 ： 可 否 独 立 运 行 ？ 内 存 空 间 ？ n2 案 例 用 程 序 来 模 拟 铁 路 售 票 系 统 ， 实 现通 过 四 个 售 票 点 发 售 某 日 某 次 列 车 的100张 车 票 ， 要 求 这 四 个 售 票 点 同 时 售票 。 这 就 需 要 一 个 程 序 能 够 同 时 执 行 4个 任 务 。 n3 所 需 要 的 知 识 点 什 么 是 多 线 程 如 何 实 现 多 线 程 如 何 调 度 和 控 制 多 线 程 n4 多 线 程 概 述 大 多 数 程 序 设 计 时 ， 习 惯 上 考

3、虑 该 程 序如 何 从 头 至 尾 顺 序 执 行 各 项 任 务 的 设 计 方 法 ，即 一 个 程 序 只 有 一 条 执 行 路 线 。 但 现 实 世 界中 的 很 多 过 程 都 是 同 时 发 生 的 ， 对 应 这 种 情况 ， 可 编 写 有 多 条 执 行 路 径 的 程 序 ， 使 得 程序 能 够 同 时 执 行 多 个 任 务 。 n5 线 程 的 基 本 概 念 线 程 是 程 序 中 的 一 条 执 行 路 径 。 多 线 程 是指 程 序 中 包 含 多 条 执 行 路 径 。 在 一 个 程 序 中 可 以 同 时 运 行 多 个 不 同 的 线程 来 执

4、行 不 同 的 任 务 。 n6 多 线 程 基 本 概 念 n7 多 线 程 的 例 子 浏 览 器 程 序 聊 天 程 序 n8 v 进 程 ： 简 单 地 说 ， 在 多 任 务 系 统 中 ， 每 个 独 立 执 行的 程 序 称 为 进 程 ， 也 就 是 “ 正 在 运 行 的 程 序 ” 。v 线 程 ： 进 程 中 程 序 代 码 的 一 个 执 行 序 列 。 线 程 并 不 是程 序 ， 它 自 己 本 身 并 不 能 运 行 ， 必 须 在 程 序 中 运 行 。 在一 个 程 序 中 可 以 实 现 多 个 线 程 ， 这 些 线 程 同 时 运 行 ， 完成 不 同

5、的 功 能 。 进 程 与 线 程 n9 线 程 与 进 程 的 区 别进 程 和 线 程 相 比 ， 主 要 有 以 下 区 别 ： 两 者 的 粒 度 不 同 ， 是 两 个 不 同 层 次 上 的 概 念 。进 程 是 由 操 作 系 统 来 管 理 的 ， 而 线 程 则 是 在 一个 程 序 （ 进 程 ） 内 。 不 同 进 程 的 代 码 、 内 部 数 据 和 状 态 都 是 完 全 独立 的 ， 而 一 个 程 序 内 的 多 线 程 是 共 享 同 一 块 内存 空 间 和 同 一 组 系 统 资 源 ， 有 可 能 互 相 影 响 。 线 程 本 身 的 数 据 通 常

6、只 有 寄 存 器 数 据 ， 以 及 一个 程 序 执 行 时 使 用 的 堆 栈 ， 所 以 线 程 的 切 换 比进 程 切 换 的 负 担 要 小 。 n10 分 时 操 作 系 统 可 以 同 一 时 间 执 行 多 个 程 序 的 操 作 系 统 CPU只 是 将 时 间 切 割 为 时 间 片 ， 然 后 将 时 间 片分 配 给 这 些 程 序 ， 获 得 时 间 片 的 程 序 开 始 执 行 ，不 等 执 行 完 毕 ， 下 个 程 序 又 获 得 时 间 片 开 始 执行 ， 给 人 的 感 觉 就 像 是 多 个 程 序 在 同 时 执 行 一样 。 Java的 多 线

7、 程 就 是 在 操 作 系 统 每 次 分 时 给 Java程 序 一 个 时 间 片 的 CPU时 间 内 ， 在 若 干 独 立 的可 控 制 的 线 程 之 间 切 换 。 n11 多 线 程 编 程 的 优 点 减 轻 编 写 交 互 频 繁 、 涉 及 面 多 的 程序 的 困 难 程 序 的 吞 吐 量 会 得 到 改 善 由 多 个 处 理 器 的 系 统 ,可 以 并 发 运 行不 同 的 线 程 。 (否 则 ,任 何 时 刻 只 有一 个 线 程 在 运 行 ) n12 多 线 程 机 制 一 个 建 立 线 程 的 例 子 ：public class SimpleRun

8、nable implements Runable private String message;public static void main(String args) SimpleRunnable r1=new SimpleRunnable(H ello); Thread t1=new Thread(r1); t1.start(); public SimpleRunnable(String message) this.message = message; public void run() for(;) System.out.println(message); 线 程 开 始 执 行 时 ，

9、 它 在public void run()方 法 中 执 行 。该 方 法 是 定 义 的 线 程 执 行 起 点 ， 像 应 用 程 序 从main()开 始一 样 。首 先main()方 法 构 造SimpleRunnable类 的 实 例 。 实 例有 自 己 的 一 个 String数 据,初 始 化 为Hello。 由 实 例r1传 入Thread类 构 造 器 ， 这 是 线 程 运 行 时 处 理 的 数 据 。执 行 的 代 码 是 实 例 方 法run()。 n13 8.2 多 线 程 的 实 现 方 法 重 点 与 要 点 ：两 种 实 现 方 法 创 建 Thread子

10、类 生 成 一 个 类 ， 声 明 实 现 Runnable接 口 n14 创 建 Thread类 的 子 类 用 这 种 方 法 生 成 新 线 程 ， 可 以 按 以 下 步 骤 进 行 ：1. 生 成 Thread类 的 子 类 。 class MyThread extends Thread2. 在 子 类 中 覆 盖 run()方 法 。 public void run()3. 生 成 子 类 的 对 象 ， 并 且 调 用 start()方 法 启 动 新 线 程 。 MyThread thread = new MyThread(); thread.start(); start()方

11、 法 将 调 用 run()方 法 执 行 线 程 。 n15 实 现 Thread子 类 方 法 的 多 线 程 示 例class FirstThread extends Thread public void run() try System.out.println(First thread starts running.); for(int i=0 ; i6 ; i+) System.out.println(First + i); sleep(1 0 0 0 ); System.out.println(First thread finishes running.); catch (Inte

12、rruptedException e) n16 实 现 Thread子 类 方 法 的 多 线 程 示 例class SecondThread extends Thread public void run() try System.out.println(tSecond thread starts running.); for(int i=0 ; i6 ; i+) System.out.println(tSecond + i); sleep(1 0 0 0 ); System.out.println(tSecond thread finishes running); catch (Interr

13、uptedException e) n17 实 现 Thread子 类 方 法 的 多 线 程 示 例public class ThreadTest1 public ThreadTest1() FirstThread first = new FirstThread(); SecondThread second = new SecondThread(); first.start(); second.start();public static void main(String args) new ThreadTest1(); 结 果 为 ：First thread starts running.F

14、irst 0 Second thread starts running. Second 0First 1 Second 1First 2 Second 2First 3 Second 3First 4 Second 4First 5 Second 5 First thread finishes running. Second thread finished.n18 Thread子 类 线 程 小 结 (加 深 理 解 )需 要 深 入 理 解 线 程 的 run()以 及 start()方 法 : start()方 法 将 调 用 run()方 法 执 行 线 程 。 run()方 法 就 是

15、 新 线 程 完 成 具 体 工 作 的 地 方 。注 意 通 过 对 比 加 深 了 解 :u程 序 的 入 口 ， main() 方 法 。u线 程 的 入 口 ， run() 方 法 。 uApplet的 入 口 ， init()方 法 。 n19 案 例 的 实 现 现 在 我 们 试 着 编 程 来 模 拟 铁 路 售 票 系统 。 通 过 四 个 售 票 点 发 售 某 日 某 次 列车 的 100张 车 票 ， 一 个 售 票 点 用 一 个线 程 来 表 示 。 用 创 建 Thread类 的 子 类实 现 多 线 程 。 n20 class SailThread extend

16、s Threadstatic int x=0 ; int bh;public SailThread(int n)bh=n; public void run()while(x=9 9 ) try System.out.println(“第 ” +bh+“号 窗 口 正 在卖 出 第 +(+x)+张 票 ); sleep(5 0 0 ); catch(InterruptedException e) n21 class TestSailThread public static void main(String args) SailThread t1 =new SailThread(1 ); Sail

17、Thread t2 =new SailThread(2 ); SailThread t3 =new SailThread(3 ); SailThread t4 =new SailThread(4 ); t1 .start(); t2 .start(); t3 .start(); t4 .start(); n22 n23 8. 多 线 程 实 现 方 法2 实 现 Runnable接 口 什 么 是 Runnable接 口 ?a) Runnable是 java.lang包 中 的 一 个 接 口 。b) 定 义 了 创 建 和 执 行 线 程 的 功 能 。c) 定 义 了 run()方 法 ，

18、 完 成 具 体 任 务 的 地 方 。 n24 实 现 Runnable接 口实 现 Runnable接 口 的 主 要 步 骤 ： 定 义 一 个 类 实 现 Runnable接 口 ， class FirstThread implements Runnable 并 且 在 该 类 中 实 现 run()方 法 。public void run() 生 成 这 个 类 的 对 象 。 FirstThread first = new FirstThread(); 用 Thread(Runnable target)构 造 函 数 生 成 Thread对 象 ， 然 后 调 用 start()方

19、法 启 动 线 程 。 Thread thread1 = new Thread(first); thread1 .start(); n25 实 现 Runnable接 口 多 线 程 示 例class FirstThread implements Runnable public void run() try System.out.println(First thread starts running.); for(int i=0 ; i6 ; i+) System.out.println(First + i); Thread.sleep(1 0 0 0 ); System.out.printl

20、n(First thread finishes running.); catch (InterruptedException e) class SecondThread implements Runnable public void run() try System.out.println(tSecond thread starts running.); for(int i=0 ; i6 ; i+) System.out.println(tSecond + i); Thread.sleep(1 0 0 0 ); System.out.println(tSecond thread finishe

21、d.); catch(InterruptedException e) n26 实 现 Runnable接 口 多 线 程 示 例public class RunTest public RunTest() FirstThread first = new FirstThread(); SecondThread second = new SecondThread(); Thread thread1 = new Thread(first); Thread thread2 = new Thread(second); thread1 .start(); thread2 .start(); public s

22、tatic void main(String args) new RunTest(); 结 果 为 ：First thread starts running.First 0 Second thread starts running. Second 0First 1 Second 1First 2 Second 2First 3 Second 3First 4 Second 4First 5 Second 5 First thread finishes running. Second thread finished.n27 案 例 的 实 现 用 Runnable接 口 来 实 现 铁 路 售

23、票 程 序 。 n28 class SailRun implements Runnableint x=0 ; Thread t; public void run() String bh=t.currentThread().getName(); while(x Thread类 的 子 类 。实 现 runnable接 口 相 对 于 继 承 Thread类 来 说 ， 具 有 以 下 优 点 ：v可 以 避 免 由 于 Java单 继 承 特 性 带 来 的 局 限 。v有 利 于 程 序 的 健 壮 性 ， 代 码 能 够 被 多 个 线 程 共 享 ， 代 码与 数 据 是 独 立 的 。

24、n32 8.3多 线 程 状 态 及 调 度 1 线 程 的 状 态 具 有 四 种 状 态 ： 新 生 态 ： 已 分 配 内 在 ， 未 高 度 可 执 行 态 ： start( ) 阻 塞 态 停 止 态 ： stop( ) n33 线 程 状 态四 种 状 态 的 相 关 概 念 生 命 周 期 如 下 ：1 新 建 ：当 一 个 Thread类 或 其 子 类 的 对 象 被 创 建 后 ， 进入 这 个 状 态 。这 时 ， 线 程 对 象 已 被 分 配 内 存 空 间 ， 其 私 有 数据 已 被 初 始 化 ， 但 该 线 程 还 未 被 调 度 ， 可 用start()方

25、法 调 度 ， 或 用 stop()方 法 中 止 。新 生 线 程 一 旦 被 调 度 ， 就 将 切 换 到 可 执 行 状 态 。 n34 线 程 状 态2 可 运 行 ：处 于 可 执 行 环 境 中 ， 随 时 可 以 被 调 度 而 执 行 。 它可 细 分 为 两 个 子 状 态 ：运 行 状 态 ， 已 获 得 CPU， 正 在 执 行 ；就 绪 状 态 ， 只 等 待 处 理 器 资 源 。这 两 个 子 状 态 的 过 渡 由 执 行 调 度 器 来 控 制 。3 阻 塞 ：由 某 种 原 因 引 起 线 程 暂 停 执 行 的 状 态 。 n35 线 程 状 态4 死 亡

26、 ：线 程 执 行 完 毕 或 另 一 线 程 调 用 stop()方 法 使其 停 止 时 ， 进 入 这 种 停 止 状 态 。它 表 示 线 程 已 退 出 可 运 行 状 态 ， 并 且 不 再进 入 可 运 行 状 态 。 n36 8.3.2 线 程 优 先 级 及 调 度 问 题 ： 线 程 为 什 么 需 要 调 度 ？ 为 什 么 引 入 优 先 级 ？ 应 用 程 序 中 的 多 个 线 程 能 够 并 发 执 行 ， 但 从 系 统 的 内 部 来看 ， 所 有 线 程 仍 然 是 串 行 的 一 个 一 个 地 执 行 ， 那 么 如 何 来决 定 哪 一 个 线 程 先

27、 执 行 ， 哪 一 个 线 程 后 执 行 呢 ？ Java引 入 了 优 先 级 的 概 念 ， 优 先 级 就 是 线 程 获 得 CPU而 执行 的 优 先 程 度 ， 优 先 级 越 高 ， 获 得 CPU的 权 力 越 大 ， 执 行的 机 会 越 多 ， 执 行 的 时 间 也 越 长 。 n37 线 程 优 先 级 Java把 优 先 级 划 分 为 1 0 级 ， 用 1 至 1 0 的 整 数 表 示 ， 数值 越 大 ， 优 先 级 越 高 。 在 Thread类 中 定 义 了 三 个 优 先 级 常 量 ：MIN_PRIORITY, MAX_PRIORITY和 NOR

28、M_PRIORITY，其 值 分 别 为 1 , 1 0 , 5 。 在 为 线 程 分 配 优 先 级 时 ， 其 值 应 该 在 1 至 1 0 之 间 ，否 则 将 出 错 。 如 果 应 用 程 序 没 有 为 线 程 分 配 优 先 级 ， 则 Java系 统为 其 赋 值 为 NORM_PRIORITY。 n38 线 程 调 度 原 则 调 度 就 是 分 配 CPU资 源 ， 确 定 线 程 的 执 行 顺 序 。 Java采 用 抢 占 式 调 度 方 式 ， 即 高 优 先 级 线 程 具 有 剥夺 低 优 先 级 线 程 执 行 的 权 力 。 如 果 一 个 低 优 先

29、线 程 正 在 执 行 ， 这 时 出 现 一 个 高 优先 级 线 程 ， 那 么 低 优 先 级 线 程 就 只 能 停 止 执 行 ， 放弃 CPU， 推 回 到 等 待 队 列 中 ， 等 待 下 一 轮 执 行 ， 而让 高 优 先 级 线 程 立 即 执 行 。 如 果 线 程 具 有 相 同 的 优 先 级 ， 则 按 先 来 先 服 务 的原 则 调 度 。 n39 线 程 调 度 原 则 问 题 ： 如 果 高 优 先 级 抢 占 了 低 优 先 级 的 线 程 后 ，一 直 占 据 CPU， 低 优 先 级 的 线 程 如 何 获 得 控 制 权 ？ 有 两 个 方 法 可

30、 以 改 变 这 种 现 象 ：一 是 调 用 sleep()方 法 ， 暂 时 进 入 睡 眠 状 态 ， 从 而 让 出CPU， 使 有 相 同 优 先 级 线 程 和 低 优 先 级 线 程 有 执 行 的 机会 。二 是 调 用 yield()而 放 弃 CPU， 这 时 和 它 有 相 同 优 先 级 的线 程 就 有 执 行 的 机 会 。 n40 8.3.3 线 程 的 控 制必 须 了 解 Java程 序 的 线 程 结 构 ： 每 个 Java程 序 都 有 一 个 缺 省 的 主 线 程 ：Application， 主 线 程 是 main方 法 执 行 的 线 索 ；Ap

31、plet， 主 线 程 指 挥 浏 览 器 加 载 并 执 行 Java小 程序 。 要 想 实 现 多 线 程 ， 必 须 在 主 线 程 中 创 建 新 的 线 程 对象 。 n41 线 程 的 状 态 转 换 图 阻 塞死 亡可 运 行 suspend()sleep()wait()I/O blockingresume()sleep time_out notify()I/O finished新 建new语 句 start() Stop() Stop()Stop() n42 线 程 控 制 方 法Thread类 定 义 了 许 多 控 制 线 程 执 行 的 方 法 。 程 序 中 经 常

32、使 用 下 面 的 方 法 ， 对 线 程 进 行 控 制 ： start()： 用 于 调 用 run()方 法 使 线 程 开 始 执 行 。stop()： 立 即 停 止 线 程 执 行 ， 其 内 部 状 态 清 零 ，放 弃 占 用 资 源 。suspend()： 暂 停 线 程 执 行 。 线 程 的 所 有 状 态 和资 源 保 持 不 变 ， 以 后 可 以 通 过 另 一 线 程 调 用resume()方 法 来 重 新 启 动 这 个 线 程 。 n43 线 程 控 制 方 法resume()： 恢 复 暂 停 的 线 程 ， 安 排 暂 停 线 程 执 行 。 sleep

33、()： 调 整 Java执 行 时 间 ， 所 需 参 数 是 指 定 线 程的 睡 眠 时 间 ， 以 毫 秒 为 单 位 。join()： 调 用 线 程 等 待 本 线 程 执 行 结 束 。yield()： 暂 停 调 度 线 程 并 将 其 放 在 等 待 队 列 末 尾 ，等 待 下 一 轮 执 行 ， 使 同 优 先 级 的 其 它 线 程 有 机 会执 行 。 n44 线 程 控 制 方 法isAlive()：线 程 处 于 “ 新 建 ” 状 态 时 ， 线 程 调 用 方 法 返 回 false。当 一 个 线 程 调 用 start（ ） 方 法 ， 并 占 有 CPU资

34、 源 后 ，该 线 程 的 run方 法 就 开 始 运 行 ， 在 线 程 的 run方 法 结 束之 前 ， 即 没 有 进 入 死 亡 状 态 之 前 ， 线 程 调 用 isAlive()方法 返 回 true。当 线 程 进 入 “ 死 亡 ” 状 态 后 （ 实 体 内 存 被 释 放 ） ， 线程 仍 可 以 调 用 方 法 isAlive（ ） ， 这 时 返 回 的 值 是 false。 n45 8 .4 线 程 同 步为 什 么 需 要 线 程 同 步 ？ 多 线 程 提 高 了 程 序 的 并 发 度 ， 但 是 有 时 候 是 不 安 全 的 或 者 不 合逻 辑 的

35、。 则 需 要 多 线 程 同 步 。 线 程 同 步 是 多 线 程 编 程 的 一 个 相 当 重 要 的 技 术 。 多 线 程 同 步 控 制 机 制 ： 保 证 同 一 时 刻 只 有 一 个 线 程 访 问 数 据 资源 。 同 步 锁 ： Java用 锁 标 志 (lock flag)的 手 段 ， 对 被 访 问 的 数 据 进 行同 步 限 制 ， 从 而 实 现 对 数 据 的 保 护 。 把 所 有 被 保 护 资 源 都 加 上 锁 标 志 ， 线 程 必 须 取 得 锁 标 志 才 能 访问 被 保 护 的 资 源 。 n46 线 程 同 步 在 Java中 ， 使

36、用 修 饰 符 synchronized来 为 被 保 护 资 源 加锁 。 synchronized只 能 用 来 说 明 方 法 和 代 码 段 ， 不 能 用 它来 说 明 类 和 成 员 变 量 。 用 synchronized修 饰 的 方 法 和 代 码 段 称 为 方 法 同 步 和代 码 段 同 步 ， 它 意 味 着 同 一 时 刻 该 方 法 或 代 码 段 只 能被 一 个 线 程 执 行 ， 其 它 想 执 行 该 方 法 或 代 码 段 的 线 程必 须 等 待 。 方 法 同 步 仅 在 该 方 法 前 加 上 synchronized修 饰 符 即 可 。 n47

37、 线 程 同 步 同 步 操 作 是 以 牺 牲 CPU资 源 为 代 价 的 。 正 确 使 用 同 步 可 以 减 少 线 程 间 的 相 互 干 扰 ， 提 高 程 序的 稳 定 性 和 可 靠 性 。 Java程 序 中 多 个 线 程 可 以 通 过 消 息 来 实 现 互 动 联 系 的 ，通 常 可 以 用 notify()或 notifyAll()方 法 唤 醒 其 它 一 个 或 所有 线 程 。 使 用 wait()方 法 来 使 该 线 程 处 于 阻 塞 状 态 ， 等 待 其 它 的线 程 用 notify()唤 醒 。 n48 8 .5 线 程 通 信 wait方

38、法 和 notify方 法 是 Java同 步 机 制 中 重 要 的 组 成 部分 。 结 合 与 synchronized关 键 字 使 用 ， 可 以 建 立 很 多 优 秀 的同 步 模 型 。 同 步 分 为 类 级 别 和 对 象 级 别 ， 分 别 对 应 着 类 锁 和 对 象 锁 。 如 果 static的 方 法 被 synchronized关 键 字 修 饰 ， 则 在 这个 方 法 被 执 行 前 必 须 获 得 类 锁 。 对 象 锁 类 似 。 n49 wait和 notify的 应 用 示 例import java.lang.Runnable;import jav

39、a.lang.Thread;class TestThread extends Threadprivate int time = 0 ;public TestThread(Runnable r,String name) super(r,name);public int getTime() return time; public int increaseTime () return +time; public class DemoThread implements Runnablepublic DemoThread() TestThread testthread1 = new TestThread

40、(this,1 ); TestThread testthread2 = new TestThread(this,2 ); testthread2 .start(); testthread1 .start(); public static void main(String args) new DemoThread(); n50 wait和 notify的 应 用 示 例public void run() TestThread t = (TestThread) Thread.currentThread(); try if (!t.getName().equalsIgnoreCase(1 ) syn

41、chronized(this) wait(); while(true) System.out.println(time in thread+ t.getName() + =+ t.increaseTime(); if(t.getTime()%1 0 = 0 ) synchronized(this) System.out.println(*); notify(); if ( t.getTime()=1 0 0 ) break; wait(); catch(Exception e) e.printStackTrace(); 结 果 为 ：time in thread1=1time in threa

42、d1=2*time in thread2=1time in thread2=2*time in thread1=11time in thread1=12*time in thread2=11time in thread2=12* n51 作 业 编 写 3 个 线 程 ， 分 别 实 现 求 同 一 组 整 数 的最 大 值 、 最 小 值 和 平 均 值 。 线 程 体 中 要求 输 出 求 值 的 过 程 。 要 求 两 种 方 法 ： （ 1 ） 继 承 Thread类 （ 2 ） 实 现 Runnable接 口 n52 设 计 一 个 Thread类 的 子 类 Mythread， 计 算1 +2 +3 +.+n的 和 。 要 求 每 循 环 一 次 ， 使 用sleep()方 法 ， 休 眠 2 0 0 毫 秒 ， 并 输 出 当 前 线程 名 和 它 的 和 。 然 后 创 建 Mythread类 的 两个 线 程 t1 和 t2 ， 分 别 计 算 1 +2 +.+5 0 的 和 以 及1 +2 +3 +.+1 0 0 的 和 。 注 ： 线 程 t1 的 线 程 名为 ”5 0 的 和 ”， 线 程 t2 的 线 程 名 为 “ 1 0 0 的 和 ” n53 谢 谢 ！ n54