• 那是从何处传来的钟声呢？偶尔听到那钟声，平添一份喜悦与向往之情。
> 后端 > java三个线程同步的两种方法

java三个线程同步的两种方法

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

首先给出题目要求

甲线程输出：A、B、C、D、E

乙线程输出：1、2、3、4、5

丙线程数出：甲、乙、丙、丁、戊

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

A 1 甲 B 2 乙 C 3 丙 D 4 丁 E 5 戊

无非都是同步，消费者生产者的例子比较好，实现方法也是各有不同，这里自己整理了两种方法，做个笔记。

方法一代码

  1. package com.liuyanzhao;
  3. /*
  4.  *
  5.  * @author WellsLiu
  6.  *
  7.  */
  8. class MySignal {
  9.     int data = 0;
  10. }
  12. class MyThread implements Runnable {
  13.     MySignal s = new MySignal();
  14.     char c[];
  15.     int runFlag;
  16.     int nextFlag;
  18.     public MyThread(MySignal s, char[] c, int x, int y) {
  19.         this.s = s;
  20.         this.c = c;
  21.         runFlag = x;
  22.         nextFlag = y;
  24.     }
  26.     public void run() {
  27.         synchronized (s) {
  28.             for (int i = 0; i < c.length; i++) {
  29.                 while (s.data != runFlag) {
  30.                     try {
  31.                         s.wait();
  32.                     } catch (InterruptedException e) {
  33.                         e.printStackTrace();
  34.                     }
  35.                 }
  36.                 System.out.print(c[i] + ” “);
  37.                 s.data = nextFlag;
  38.                 s.notifyAll();
  39.             }
  40.         }
  41.     }
  42. }
  44. public class Test {
  45.     public static void main(String[] args) {
  46.         MySignal s = new MySignal();
  47.         char[] c1 = { ‘A’, ‘B’, ‘C’, ‘D’, ‘E’ };
  48.         char[] c2 = { ‘1‘, ‘2‘, ‘3‘, ‘4‘, ‘5‘ };
  49.         char[] c3 = { ‘甲’, ‘乙’, ‘丙’, ‘丁’, ‘戊’ };
  50.         Thread t1 = new Thread(new MyThread(s, c1, 0, 1));
  51.         Thread t2 = new Thread(new MyThread(s, c2, 1, 2));
  52.         Thread t3 = new Thread(new MyThread(s, c3, 2, 0));
  53.         t1.start();
  54.         t2.start();
  55.         t3.start();
  56.     }
  57. }

 

方法二代码

  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 []c = {‘A’, ‘B’, ‘C’, ‘D’, ‘E’};
  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(c[i]+” “);
  32.                 i++;
  33.                 res.notifyAll();
  34.                 res.flag=2;
  35.             }
  36.         }
  37.     }
  38. }
  40. class Thread2 extends Thread {
  41.     Resource res;
  42.     public Thread2(Resource res) {
  43.         this.res = res;
  44.     }
  45.     int i=0;
  46.     char []c = {‘1‘, ‘2‘, ‘3‘, ‘4‘, ‘5‘};
  47.     public  void run() {
  48.         synchronized (res) {
  49.             while(i<5) {
  50.                 while(res.flag!=2) {
  51.                     try {
  52.                         res.wait();
  53.                     } catch (InterruptedException e) {
  54.                         e.printStackTrace();
  55.                     }
  56.                 }
  58.                 System.out.print(c[i]+” “);
  59.                 i++;
  60.                 res.notifyAll();
  61.                 res.flag=3;
  62.             }
  63.         }
  64.     }
  65. }
  67. class Thread3 extends Thread {
  68.     Resource res;
  69.     public Thread3(Resource res) {
  70.         this.res = res;
  71.     }
  72.     char []c = {‘甲’,’乙’,’丙’,’丁’,’戊’};
  73.     public  void run() {
  74.         synchronized (res) {
  75.             for(int i=0;i<c.length;i++){
  76.                 while(res.flag!=3) {
  77.                     try {
  78.                         res.wait();
  79.                     } catch (InterruptedException e) {
  80.                         e.printStackTrace();
  81.                     }
  82.                 }
  83.                 System.out.print(c[i]+” “);
  85.                 res.notifyAll();
  86.                 res.flag=1;
  88.             }
  89.         }
  90.     }
  91. }
  93. public class Test1 {
  94.     public static void main(String[] args) {
  95.         Resource res = new Resource();
  96.         Thread1 t1 = new Thread1(res);
  97.         Thread2 t2 = new Thread2(res);
  98.         Thread3 t3 = new Thread3(res);
  99.         t1.start();
  100.         t2.start();
  101.         t3.start();
  102.     }
  103. }

明显，方法一的代码更美观，通用。

 

何处钟 , 版权所有丨如未注明 , 均为原创丨本网站采用BY-NC-SA协议进行授权
转载请注明原文链接：java 三个线程同步的两种方法
喜欢 (0)赏
[15211539367@163.com]
分享 (0)
Nanait
关于作者：
作者主页 赞助作者

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