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

avatar 2017年05月29日13:59:56 1 1920 views
博主分享免费Java教学视频，B站账号：Java刘哥
题目
借助同步机制、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. }
运行结果如下   本文链接：https://liuyanzhao.com/4481.html
历史上的今天
五月
29日
  • 微信
  • 交流学习，有偿服务
  • weinxin
  • 博客/Java交流群
  • 资源分享，问题解决，技术交流。群号：590480292
  • weinxin
avatar

发表评论

avatar 登录者：匿名
匿名评论，评论回复后会有邮件通知

  

已通过评论：0   待审核评论数：0