多线程leetcode编程题

synchronized 实现

1. class ReentrantTest {
2.     private  int n;
3.     private volatile int flag = 1;
4.     private Object lock = new Object();
6.     public ReentrantTest(int n) {
7.         this.n = n;
8.     }
10.     public void zero(IntConsumer printNumber) throws InterruptedException{
11.         for(int i=1;i<=n;){
12.             synchronized (lock){
13.                 if(flag%4==1 ||flag%4==3){
14.                     System.out.println(0);
15.                     flag++;
16.                     i++;
17.                     lock.notifyAll();
18.                 } else{
19.                     lock.wait();
20.                 }
21.             }
22.         }
23.     }
25.     public void odd(IntConsumer printNumber) throws InterruptedException {
26.         for(int i=1;i<=n;){
27.             synchronized (lock) {
28.              if(flag%4 == 2){
29.                  System.out.println(i);
30.                  i = i+2;
31.                  flag++;
32.                  lock.notifyAll();
33.              } else {
34.                  lock.wait();
35.              }
36.             }
37.         }
38.     }
40.     public void even(IntConsumer printNumber) throws InterruptedException{
41.         for(int i=2;i<=n;){
42.             synchronized (lock) {
43.                 if(flag%4 == 0){
44.                     System.out.println(i);
45.                     i = i+2;
46.                     flag++;
47.                     lock.notifyAll();
48.                 } else {
49.                     lock.wait();
50.                 }
51.             }
52.         }
53.     }
54. }

复制代码

ReentrantLock+Condition
下面为我第一遍写的错误例子
错误原因，假设先跑zero 线程，实验了 oddCondition.signalAll();后zeroCondition.await();，此时线程释放锁，而后才实验odd()线程，获取锁后oddCondition.await();，由于 .signal只能通知到已经在等候的线程，不能通知未来等候的线程，故，代码卡死了。

1. class ZeroEvenOdd {
3.     private  int n;
4.     private   ReentrantLock lock = new ReentrantLock();
5.     private  Condition zeroCondition = lock.newCondition();
6.     private  Condition evenCondition = lock.newCondition();
7.     private  Condition oddCondition = lock.newCondition();
9.     public ZeroEvenOdd(int n) {
10.         this.n = n;
11.     }
12.    
13.     public void zero() throws InterruptedException {
15.         for(int i=1;i<=n;i++){
16.             lock.lock();
17.             System.out.println(0);
18.             if(i%2==1){
19.                 oddCondition.signalAll();
20.             } else {
21.                 evenCondition.signalAll();
22.             }
23.             zeroCondition.await();
24.             lock.unlock();
25.         }
26.     }
28.     public void even() throws InterruptedException {
30.         for(int i=2;i<=n;){
31.             lock.lock();
32.             evenCondition.await();
33.             System.out.println(i);
34.             i=i+2;
35.             zeroCondition.signalAll();
36.             lock.unlock();
37.         }
39.     }
41.     public void odd() throws InterruptedException {
42.         for(int i=1;i<=n;){
43.             lock.lock();
44.             oddCondition.await();
45.             System.out.println(i);
46.             i=i+2;
47.             zeroCondition.signalAll();
48.             lock.unlock();
49.         }
50.     }

复制代码

修改如下

1. class ZeroEvenOdd {
3.     private  int n;
4.     private   ReentrantLock lock = new ReentrantLock();
5.     private  Condition zeroCondition = lock.newCondition();
6.     private  Condition evenCondition = lock.newCondition();
7.     private  Condition oddCondition = lock.newCondition();
8.     private volatile int flag = 1;
10.     public ZeroEvenOdd(int n) {
11.         this.n = n;
12.     }
14.     public void zero() throws InterruptedException {
16.         for(int i=1;i<=n;){
17.             lock.lock();
18.             if(flag%4 ==1 || flag%4 == 3){
19.                 System.out.println(0);
20.                 flag++;
21.                 i++;
22.                 if(flag%4 ==0){
23.                     evenCondition.signal();
24.                 } else {
25.                     oddCondition.signal();
26.                 }
27.             } else {
28.                 zeroCondition.await();
29.             }
30.             lock.unlock();
31.         }
32.     }
34.     //偶数
35.     public void even() throws InterruptedException {
37.         for(int i=2;i<=n;){
38.             lock.lock();
39.             if(flag%4 ==0){
40.                 System.out.println(i);
41.                 i=i+2;
42.                 flag++;
43.                 zeroCondition.signal();
44.             } else {
45.                 evenCondition.await();
46.             }
47.             lock.unlock();
48.         }
50.     }
52.     //奇数
53.     public void odd() throws InterruptedException {
54.         for(int i=1;i<=n;){
55.             lock.lock();
56.             if(flag%4 == 2){
57.                 System.out.println(i);
58.                 i=i+2;
59.                 flag++;
60.                 zeroCondition.signal();
61.             } else {
62.                 oddCondition.await();
63.             }
64.             lock.unlock();
65.         }
66.     }
67.    
68. }

复制代码

下面这个解的重点是notify 和 notifyAll 的区别
notify和notifyAll的区别
首先讲这俩区别之前先来了解两个概念。锁池EntryList和等候池WaitSet。而这两个池和Object基类的notify
锁池
假设线程A已经拥有了某个对象(不是类)的锁，而其它线程B、C想要调用这个对象的某个synchronized方法(或者代码块), 由于B、C线程在进入对象的synchronized方法(或者块)之前必须先得到该对象锁的拥有权，而碰巧该对象的锁目前正被线程A所占用，此时B、C线程就会被阻塞，进入一个地方去等候锁的释放，这个地方便是该对象的锁池
等候池
假设线程A调用了某个对象的wait()方法，线程A就会释放该对象的锁，同时线程A就进入到了该对象的等候池中，进入到等候池中的线程不会去竞争该对象的锁。
notifyAll会让所有处于等候池的线程全部进入锁池去竞争获取锁的机会
notify只会随机选取一个处于等候池中的线程进入锁池去竞争获取锁的机会
分析：
当current = 1时，实验number()里面，其他线程要么为实验，要么lock.wait();在等候池里，current =3时，number()进入等候池，由于 lock.notifyAll();唤醒了其他几个线程进入锁池，除了fizz满足条件，其他线程都实验了lock.wait();重新进入等候池。

1. class FizzBuzz {
2.     private int n;
3.     private final Object lock;
4.     private int current;
6.     public FizzBuzz(int n) {
7.         this.n = n;
8.         current = 1;
9.         lock = new Object();
10.     }
12.     // printFizz.run() outputs "fizz".
13.     public void fizz(Runnable printFizz) throws InterruptedException {
14.         synchronized (lock) {
15.             while (current <= n) {
16.                 if (current % 3 == 0 && current % 5 != 0) {
17.                     current++;
18.                     printFizz.run();
19.                     lock.notifyAll();
20.                 } else {
21.                     lock.wait();
22.                 }
23.             }
24.         }
26.     }
28.     // printBuzz.run() outputs "buzz".
29.     public void buzz(Runnable printBuzz) throws InterruptedException {
30.         synchronized (lock) {
31.             while (current <= n) {
32.                 if (current % 5 == 0 && current % 3 != 0) {
33.                     current++;
34.                     printBuzz.run();
35.                     lock.notifyAll();
36.                 } else {
37.                     lock.wait();
38.                 }
39.             }
40.         }
42.     }
44.     // printFizzBuzz.run() outputs "fizzbuzz".
45.     public void fizzbuzz(Runnable printFizzBuzz) throws InterruptedException {
46.         synchronized (lock) {
47.             while (current <= n) {
48.                 if (current % 15 == 0) {
49.                     current++;
50.                     printFizzBuzz.run();
51.                     lock.notifyAll();
52.                 } else {
53.                     lock.wait();
54.                 }
55.             }
56.         }
57.     }
59.     // printNumber.accept(x) outputs "x", where x is an integer.
60.     public void number(IntConsumer printNumber) throws InterruptedException {
61.         synchronized (lock) {
62.             while (current <= n) {
63.                 if (current % 3 != 0 && current % 5 != 0) {
64.                     printNumber.accept(current);
65.                     current++;
66.                     lock.notifyAll();
67.                 } else {
68.                     lock.wait();
69.                 }
70.             }
71.         }
72.     }
73. }

复制代码

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