synchronized wait()/notify 对比 ReentrantLock await()/signal()

结论

synchronized

   synchronized 共同 wait()/notify 无法实现精准唤醒线程
  ReentrantLock

   ReentrantLock 共同 Condition await()/signal() 可以实现精准唤醒线程 (指唤醒指定的线程)
  ReentrantLock 怎样实现精准唤醒线程

   一个 lock 共同多个 Condition, 且每个 Condition 中只有一个线程
(若一个Condition中有多个线程,也无法精准唤醒线程)
  案例 synchronized

2. public class ManySync {
4.     public void await1() {
5.         synchronized (this) {
6.             try {
7.                 System.out.println("await1 - 进入等待" + Thread.currentThread().getName());
8.                 this.wait();
9.                 System.out.println("await1 - 被唤醒" + Thread.currentThread().getName());
10.             } catch (Exception e) {
11.                 e.printStackTrace();
12.             }
13.         }
14.     }
16.     public synchronized void await2() {
17.         synchronized (this) {
18.             try {
19.                 System.out.println("await2 - 进入等待" + Thread.currentThread().getName());
20.                 this.wait();
21.                 System.out.println("await2 - 被唤醒" + Thread.currentThread().getName());
22.             } catch (Exception e) {
23.                 e.printStackTrace();
24.             }
25.         }
26.     }
28.     public void await3() {
29.         synchronized (this) {
30.             try {
31.                 System.out.println("await3 - 进入等待" + Thread.currentThread().getName());
32.                 this.wait();
33.                 System.out.println("await3 - 被唤醒" + Thread.currentThread().getName());
34.             } catch (Exception e) {
35.                 e.printStackTrace();
36.             }
37.         }
38.     }
40.     public void await4() {
41.         synchronized (this) {
42.             try {
43.                 System.out.println("await4 - 进入等待" + Thread.currentThread().getName());
44.                 this.wait();
45.                 System.out.println("await4 - 被唤醒" + Thread.currentThread().getName());
46.             } catch (Exception e) {
47.                 e.printStackTrace();
48.             }
49.         }
50.     }
52.     public  void notif() {
53.         synchronized(this) {
54.             try {
55.                 this.notify();
56.                 this.notify();
57.                 this.notify();
58.                 this.notify();
59.             } catch (Exception e) {
60.                 e.printStackTrace();
61.             }
62.         }
63.     }
65. }
67. class Run3 {
69.     public static void main(String[] args) {
70.         try {
71.             ManySync manySync = new ManySync();
72.             Thread t1 = new Thread(() -> {
73.                 manySync.await1();
74.             });
75.             Thread t2 = new Thread(() -> {
76.                 manySync.await2();
77.             });
78.             Thread t3 = new Thread(() -> {
79.                 manySync.await3();
80.             });
81.             Thread t4 = new Thread(() -> {
82.                 manySync.await4();
83.             });
84.             t1.start();
85.             Thread.sleep(200);
86.             t2.start();
87.             Thread.sleep(200);
88.             t3.start();
89.             Thread.sleep(200);
90.             t4.start();
91.             Thread.sleep(1000);
92.             manySync.notif();
93.         } catch (Exception e) {
94.             e.printStackTrace();
95.         }
96.     }
97. }

复制代码

输出结果 可以看出等待时间长的锁并不会开始被唤醒, 也无法唤醒指定线程,(因为并未提供能唤醒的API,也无法进行设计) 唤醒的输出结果是随机的 由 JVM 调理

1. await1 - 进入等待Thread-0
2. await2 - 进入等待Thread-1
3. await3 - 进入等待Thread-2
4. await4 - 进入等待Thread-3
5. await1 - 被唤醒Thread-0
6. await4 - 被唤醒Thread-3
7. await3 - 被唤醒Thread-2
8. await2 - 被唤醒Thread-1

复制代码

案例 ReentrantLock

2. import java.util.concurrent.locks.Condition;
3. import java.util.concurrent.locks.Lock;
4. import java.util.concurrent.locks.ReentrantLock;
6. public class ManyCondition {
8.     private Lock lock = new ReentrantLock();
9.     Condition condition1 = lock.newCondition();
10.     Condition condition2 = lock.newCondition();
11.     Condition condition3 = lock.newCondition();
12.     Condition condition4 = lock.newCondition();
13.      public void await1() {
14.         try {
15.             lock.lock();
16.             System.out.println("await1 - 进入等待" + Thread.currentThread().getName());
17.             condition1.await();
18.             System.out.println("await1 - 被唤醒" + Thread.currentThread().getName());
19.             lock.unlock();
20.         } catch (Exception e) {
21.             e.printStackTrace();
22.         }
23.     }
25.     public void await2() {
26.         try {
27.             lock.lock();
28.             System.out.println("await2 - 进入等待" + Thread.currentThread().getName());
29.             condition2.await();
30.             System.out.println("await2 - 被唤醒" + Thread.currentThread().getName());
31.             lock.unlock();
32.         } catch (Exception e) {
33.             e.printStackTrace();
34.         }
35.     }
37.     public void await3() {
38.         try {
39.             lock.lock();
40.             System.out.println("await3 - 进入等待" + Thread.currentThread().getName());
41.             condition3.await();
42.             System.out.println("await3 - 被唤醒" + Thread.currentThread().getName());
43.             lock.unlock();
44.         } catch (Exception e) {
45.             e.printStackTrace();
46.         }
47.     }
49.     public void await4() {
50.         try {
51.             lock.lock();
52.             System.out.println("await4 - 进入等待" + Thread.currentThread().getName());
53.             condition4.await();
54.             System.out.println("await4 - 被唤醒" + Thread.currentThread().getName());
55.             lock.unlock();
56.         } catch (Exception e) {
57.             e.printStackTrace();
58.         }
59.     }
61.     public void signal() {
62.         try {
63.             lock.lock();
64.             System.out.println("await1 - 被唤醒 - " + Thread.currentThread().getName());
65.             condition1.signal();
66.             lock.unlock();
68.             lock.lock();
69.             System.out.println("await2 - 被唤醒 - " + Thread.currentThread().getName());
70.             condition2.signal();
71.             lock.unlock();
73.             lock.lock();
74.             System.out.println("await3 - 被唤醒 - " + Thread.currentThread().getName());
75.             condition3.signal();
76.             lock.unlock();
78.             lock.lock();
79.             System.out.println("await4 - 被唤醒 - " + Thread.currentThread().getName());
80.             condition4.signal();
81.             lock.unlock();
83.         } catch (Exception e) {
84.             e.printStackTrace();
85.         }
86.     }
88. }
90. class Run2 {
92.     public static void main(String[] args) {
93.              try {
94.                 ManyCondition manyCondition = new ManyCondition();
95.                 Thread t1 = new Thread(() -> {
96.                     manyCondition.await1();
97.                 });
98.                 Thread t2 = new Thread(() -> {
99.                     manyCondition.await2();
100.                 });
101.                 Thread t3 = new Thread(() -> {
102.                     manyCondition.await3();
103.                 });
104.                 Thread t4 = new Thread(() -> {
105.                     manyCondition.await4();
106.                 });
107.                 t1.start();
108.                  t2.start();
109.                  t3.start();
110.                  t4.start();
111.                 Thread.sleep(2000);
112.                 manyCondition.signal();
113.             } catch (Exception e) {
114.                 e.printStackTrace();
115.             }
116.     }
117. }

复制代码

输出结果 这里可以看出 ,当每个Condition 中只有一个线程时, 可以通过逻辑控制, 实现精准唤醒必要唤醒的线程

1. await1 - 进入等待Thread-0
2. await2 - 进入等待Thread-1
3. await3 - 进入等待Thread-2
4. await4 - 进入等待Thread-3
5. await1 - 被唤醒 - main
6. await2 - 被唤醒 - main
7. await3 - 被唤醒 - main
8. await4 - 被唤醒 - main
9. await1 - 被唤醒Thread-0
10. await2 - 被唤醒Thread-1
11. await3 - 被唤醒Thread-2
12. await4 - 被唤醒Thread-3

复制代码

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。