线程间通信

线程间通信

多线程编程步骤(中)

第一，创建资源类，创建属性和操作方法；第二，在资源操作方法，1）判断 2）工作 3）通知；第三，创建多线程调用资源类的方法。
案例

要求，有两个线程，实现对一个初始值为0的变量，一个线程对值+1，一个线程对值-1。
代码实现

1. /**
2. * @author 长名06
3. * @version 1.0
4. * 线程通信案例 两个线程对一个值进行 decr incr
5. * 用synchronized关键字实现
6. */
8. class Share {
10.     private int number;
12.     public synchronized void incr() throws InterruptedException {
13.         /**
14.          * 这样写，会出现虚假唤醒问题，因为如果当前线程被等待，然后被唤醒时，if语句，就不会再次进行判断
15.          * 有可能出现，此时的number != 0 当时依旧进行了 +1操作 减方法类似
16.          * wait()方法再api文档中，就提醒，在一个参数版本中，中断和虚假唤醒是可能的，并且该方法应该始终在循环中使用：
17.          * 线程在哪里被阻塞就会在哪里，被唤醒，也就是说线程被阻塞时，是满足number!= 0，所以阻塞，但是因为一个线程执行完后，释                  
18.          * 放锁，然后唤醒等待的线程，是随机唤醒的，有可能当前+1的条件依旧不满足，但是系统却唤醒了该线程，因为是if语句，在                         
19.          * this.wait()处被唤醒，程序继续执行，导致其实条件不满足，却执行了+1操作，所以使用while()循环进行判断，只能当条件满                  
20.          * 足且线程被唤醒才执行incr方法
21.          * if (number != 0){//条件
22.          *    this.wait();
23.          * }
24.          */
25.         while (number != 0) {
26.             this.wait();
27.         }
28.         //加1
29.         number++;
30.         System.out.println(Thread.currentThread().getName() + "\t" + number);
31.         //通知其他线程
32.         this.notifyAll();
33.     }
35.     public synchronized void decr() throws InterruptedException {
36.         while (number != 1) {
37.             this.wait();
38.         }
39.         //减1
40.         number--;
41.         System.out.println(Thread.currentThread().getName() + "\t" + number);
42.         //通知其他线程
43.         this.notifyAll();
44.     }
45. }
47. public class ThreadDemo {
48.     public static void main(String[] args) {
49.         Share share = new Share();
51.         new Thread(() -> {
52.             for (int i = 0; i < 25; i++) {
53.                 try {
54.                     share.incr();
55.                 } catch (InterruptedException e) {
56.                     e.printStackTrace();
57.                 }
58.             }
59.         }, "aa").start();
61.         new Thread(() -> {
62.             for (int i = 0; i < 25; i++) {
63.                 try {
64.                     share.decr();
65.                 } catch (InterruptedException e) {
66.                     e.printStackTrace();
67.                 }
68.             }
69.         }, "bb").start();
70.     }
71. }

复制代码

多线程编程步骤(下)

第一，创建资源类，创建属性和操作方法；第二，在资源操作方法，1) 判断 2）工作 3）通知；第三，创建多线程调用资源类的方法；第四，防止虚假唤醒问题。
Lock实现上述案例

代码

1. import java.util.concurrent.locks.Condition;
2. import java.util.concurrent.locks.Lock;
3. import java.util.concurrent.locks.ReentrantLock;
5. /**
6. * @author 长名06
7. * @version 1.0
8. */
9. //第一步创建资源类，属性和操作方法
10. class ShareByLock {
11.     private int number;
13.     //获得锁
14.     private final ReentrantLock lock = new ReentrantLock();
16.     //为当前锁，创建一个新的condition，并绑定到该锁上
17.     private Condition condition = lock.newCondition();
19.     public void incr() throws InterruptedException {
20.         //上锁
21.         lock.lock();
22.         //第二步 进行
23.         // 1.判断(线程切换的条件)
24.         // 2.执行(线程执行的具体操作)
25.         // 3.通知(唤醒等待的其他线程)
26.         try {
27.             //判断
28.             //第四步 防止虚假唤醒现象
29.             while (number != 0) {
30.                 condition.await();
31.             }
32.             //执行
33.             number++;
34.             System.out.println(Thread.currentThread().getName() + "\t" + number);
36.             //通知
37.             condition.signalAll();
38.         } finally {
39.             //解锁
40.             lock.unlock();
41.         }
42.     }
44.     public void decr() throws InterruptedException {
45.         //上锁
46.         lock.lock();
47.         try {
48.             //判断
49.             while (number != 1) {
50.                 condition.await();
51.             }
52.             //执行
53.             number--;
54.             System.out.println(Thread.currentThread().getName() + "\t" + number);
56.             //通知
57.             condition.signalAll();
58.         } finally {
59.             //解锁
60.             lock.unlock();
61.         }
62.     }
63. }
65. public class ThreadDemoByLock {
66.     public static void main(String[] args) {
68.         ShareByLock shareByLock = new ShareByLock();
69.         //第三步 创建多个线程调用资源类的方法
70.         new Thread(() -> {
71.             for (int i = 0; i < 10; i++) {
72.                 try {
73.                     shareByLock.incr();
74.                 } catch (InterruptedException e) {
75.                     e.printStackTrace();
76.                 }
77.             }
78.         }, "aa").start();
80.         new Thread(() -> {
81.             for (int i = 0; i < 10; i++) {
82.                 try {
83.                     shareByLock.decr();
84.                 } catch (InterruptedException e) {
85.                     e.printStackTrace();
86.                 }
87.             }
88.         }, "bb").start();
90.         new Thread(() -> {
91.             for (int i = 0; i < 10; i++) {
92.                 try {
93.                     shareByLock.incr();
94.                 } catch (InterruptedException e) {
95.                     e.printStackTrace();
96.                 }
97.             }
98.         }, "cc").start();
100.         new Thread(() -> {
101.             for (int i = 0; i < 10; i++) {
102.                 try {
103.                     shareByLock.decr();
104.                 } catch (InterruptedException e) {
105.                     e.printStackTrace();
106.                 }
107.             }
108.         }, "dd").start();
110.     }
111. }

复制代码

只是为了记录自己的学习历程，且本人水平有限，不对之处，请指正。

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！