Condition类的await()、signal()和signalAll()相当于 Object 的 wait()、notify()和notifyAll()

    当Lock锁使用公平模式的时候，可以使用Condition的signal(),线程会按照FIFO的顺序冲await()中唤醒

    我们根据结果可知，abcd的顺序并不是有序的，如果我们想让线程有序，必须用多个Condition条件来实现

    1. import java.util.concurrent.locks.Condition;
    2. import java.util.concurrent.locks.Lock;
    3. import java.util.concurrent.locks.ReentrantLock;
    5. public class B  {
    6.     public static void main(String[] args) {
    7.         Data2 data = new Data2();
    9.         new Thread(()->{
    10.             for (int i = 0; i < 10; i++) {
    11.                 try {
    12.                     data.increment();
    13.                 } catch (InterruptedException e) {
    14.                     e.printStackTrace();
    15.                 }
    16.             }
    17.         },"A").start();
    19.         new Thread(()->{
    20.             for (int i = 0; i < 10; i++) {
    21.                 try {
    22.                     data.decrement();
    23.                 } catch (InterruptedException e) {
    24.                     e.printStackTrace();
    25.                 }
    26.             }
    27.         },"B").start();
    29.         new Thread(()->{
    30.             for (int i = 0; i < 10; i++) {
    31.                 try {
    32.                     data.increment();
    33.                 } catch (InterruptedException e) {
    34.                     e.printStackTrace();
    35.                 }
    36.             }
    37.         },"C").start();
    39.         new Thread(()->{
    40.             for (int i = 0; i < 10; i++) {
    41.                 try {
    42.                     data.decrement();
    43.                 } catch (InterruptedException e) {
    44.                     e.printStackTrace();
    45.                 }
    46.             }
    47.         },"D").start();
    49.     }
    50. }
    52. // 判断等待，业务，通知
    53. class Data2{ // 数字 资源类
    55.     private int number = 0;
    57.     Lock lock = new ReentrantLock();
    58.     Condition condition = lock.newCondition();
    60.     //condition.await(); // 等待
    61.     //condition.signalAll(); // 唤醒全部
    62.     //+1
    63.     public void increment() throws InterruptedException {
    64.         lock.lock();
    65.         try {
    66.             // 业务代码
    67.             while (number!=0){  //0
    68.                 // 等待
    69.                 condition.await();
    70.             }
    71.             number++;
    72.             System.out.println(Thread.currentThread().getName()+"=>"+number);
    73.             // 通知其他线程，我+1完毕了
    74.             condition.signalAll();
    75.         } catch (Exception e) {
    76.             e.printStackTrace();
    77.         } finally {
    78.             lock.unlock();
    79.         }
    81.     }
    83.     //-1
    84.     public  void decrement() throws InterruptedException {
    85.         lock.lock();
    86.         try {
    87.             while (number==0){ // 1
    88.                 // 等待
    89.                 condition.await();
    90.             }
    91.             number--;
    92.             System.out.println(Thread.currentThread().getName()+"=>"+number);
    93.             // 通知其他线程，我-1完毕了
    94.             condition.signalAll();
    95.         } catch (Exception e) {
    96.             e.printStackTrace();
    97.         } finally {
    98.             lock.unlock();
    99.         }
    100.     }
    102. }
    1. A=>1
    2. B=>0
    3. A=>1
    4. B=>0
    5. A=>1
    6. B=>0
    7. A=>1
    8. B=>0
    9. A=>1
    10. B=>0
    11. A=>1
    12. D=>0
    13. A=>1
    14. D=>0
    15. A=>1
    16. D=>0
    17. A=>1
    18. D=>0
    19. A=>1
    20. D=>0
    21. C=>1
    22. D=>0
    23. C=>1
    24. D=>0
    25. C=>1
    26. D=>0
    27. C=>1
    28. D=>0
    29. C=>1
    30. D=>0
    31. C=>1
    32. B=>0
    33. C=>1
    34. B=>0
    35. C=>1
    36. B=>0
    37. C=>1
    38. B=>0
    39. C=>1
    40. B=>0