• 那是从何处传来的钟声呢？偶尔听到那钟声，平添一份喜悦与向往之情。
> 后端 > java线程输出线程开始：1-2-a## 3-4-b## 5-6-c## 7-8-d## 9-0-e## 线程结束

java线程输出线程开始：1-2-a## 3-4-b## 5-6-c## 7-8-d## 9-0-e## 线程结束

后端 Nanait 13年前 (2012-08-07) 52次浏览 已收录 0个评论 扫描二维码

题目

借助同步机制、sleep()方法、join()方法，实现动画显示：

甲线程输出：1、3、5、7、9

乙线程输出：2、4、6、8、0

丙线程数出：a、b、c、d、e

main 线程输出：线程开始、线程结束

最终输出结果为（注：这是唯一可能的结果）

线程开始：1-2-a## 3-4-b## 5-6-c## 7-8-d## 9-0-e## 线程结束

要求：每隔一秒输出一个字符。（借助 sleep）

分析

可以参考Java 线程生产者和消费者实例

代码如下

  1. package com.liuyanzhao;
  3. /*
  4.  *
  5.  * @author WellsLiu
  6.  *
  7.  */
  9. class Resource {
  10.     int flag=1;
  11. }
  13. class Thread1 extends Thread {
  14.     Resource res;
  15.     public Thread1(Resource res) {
  16.         this.res = res;
  17.     }
  18.     int i=0;
  19.     char []c1 = {‘1‘,’3‘,’5‘,’7‘,’9‘};
  20.     public  void run() {
  21.         synchronized (res) {
  22.             while(i<5) {
  23.                 while(res.flag!=1) {
  24.                     try {
  25.                         res.wait();//t1
  26.                     } catch (InterruptedException e) {
  27.                         e.printStackTrace();
  28.                     }
  29.                 }
  31.                 System.out.print(c1[i]);
  32.                 try {
  33.                     sleep(1000);
  34.                 } catch (InterruptedException e) {
  35.                     e.printStackTrace();
  36.                 }
  37.                 System.out.print(“-“);
  38.                 try {
  39.                     sleep(1000);
  40.                 } catch (InterruptedException e) {
  41.                     e.printStackTrace();
  42.                 }
  43.                 i++;
  44.                 res.notifyAll();
  45.                 res.flag=2;
  46.             }
  47.         }
  48.     }
  49. }
  51. class Thread2 extends Thread {
  52.     Resource res;
  53.     public Thread2(Resource res) {
  54.         this.res = res;
  55.     }
  56.     int i=0;
  57.     char []c1 = {‘2‘,’4‘,’6‘,’8‘,’0‘};
  58.     public  void run() {
  59.         synchronized (res) {
  60.             while(i<5) {
  61.                 while(res.flag!=2) {
  62.                     try {
  63.                         res.wait();
  64.                     } catch (InterruptedException e) {
  65.                         e.printStackTrace();
  66.                     }
  67.                 }
  69.                 System.out.print(c1[i]);
  70.                 try {
  71.                     sleep(1000);
  72.                 } catch (InterruptedException e) {
  73.                     e.printStackTrace();
  74.                 }
  75.                 System.out.print(“-“);
  76.                 try {
  77.                     sleep(1000);
  78.                 } catch (InterruptedException e) {
  79.                     // TODO Auto-generated catch block
  80.                     e.printStackTrace();
  81.                 }
  83.                 i++;
  84.                 res.notifyAll();
  85.                 res.flag=3;
  86.             }
  87.         }
  88.     }
  89. }
  91. class Thread3 extends Thread {
  92.     Resource res;
  93.     public Thread3(Resource res) {
  94.         this.res = res;
  95.     }
  96.     int i=0;
  97.     char []c1 = {‘a’,’b’,’c’,’d’,’e’};
  98.     public  void run() {
  99.         synchronized (res) {
  100.             while(i<5) {
  101.                 while(res.flag!=3) {
  102.                     try {
  103.                         res.wait();
  104.                     } catch (InterruptedException e) {
  105.                         e.printStackTrace();
  106.                     }
  107.                 }
  108.                 System.out.print(c1[i]);
  109.                 try {
  110.                     sleep(1000);
  111.                 } catch (InterruptedException e) {
  112.                     e.printStackTrace();
  113.                 }
  114.                 System.out.print(“#”);
  115.                 try {
  116.                     sleep(1000);
  117.                 } catch (InterruptedException e) {
  118.                     e.printStackTrace();
  119.                 }
  120.                 System.out.print(“#”);
  121.                 try {
  122.                     sleep(1000);
  123.                 } catch (InterruptedException e) {
  124.                     e.printStackTrace();
  125.                 }
  126.                 System.out.print(” “);
  128.                 i++;
  129.                 res.notifyAll();
  130.                 res.flag=1;
  131.             }
  132.         }
  133.     }
  134. }
  136. public class Test1 {
  137.     public static void main(String[] args) throws InterruptedException {
  138.         System.out.printf(“线程开始: “);
  139.         Resource res = new Resource();
  140.         Thread1 t1 = new Thread1(res);
  141.         Thread2 t2 = new Thread2(res);
  142.         Thread3 t3 = new Thread3(res);
  143.         t1.start();
  144.         t2.start();
  145.         t3.start();
  147.         t1.join();
  148.         t3.join();
  149.         t2.join();
  150.         System.out.print(“线程结束”);
  151.     }
  152. }

运行结果如下

java 线程输出线程开始：1-2-a## 3-4-b## 5-6-c## 7-8-d## 9-0-e## 线程结束

 

何处钟 , 版权所有丨如未注明 , 均为原创丨本网站采用BY-NC-SA协议进行授权
转载请注明原文链接：java 线程输出线程开始：1-2-a## 3-4-b## 5-6-c## 7-8-d## 9-0-e## 线程结束
喜欢 (0)赏
[15211539367@163.com]
分享 (0)
Nanait
关于作者：
作者主页 赞助作者

您必须 登录 才能发表评论！