有顺序的唤醒线程

    说几个重点：
    因为线程是根据cpu随机调度的，所以，这个是不确定的，但是，你进了方法，你不符合条件，我就让你干等，
    这样我就实现了线程的顺序执行。
    A抢到锁了，必须等A把锁释放，其他人才能再抢到锁走自己的逻辑。。。

    A 执行完调用B，B执行完调用C，C执行完调用A

    1. package com.juc.等待唤醒;
    3. import java.util.concurrent.locks.Condition;
    4. import java.util.concurrent.locks.Lock;
    5. import java.util.concurrent.locks.ReentrantLock;
    7. /**
    8.  * A 执行完调用B，B执行完调用C，C执行完调用A
    9.  */
    10. public class C {
    12.     public static void main(String[] args) {
    13.         Data3 data = new Data3();
    15.         new Thread(()->{
    16.             for (int i = 0; i <10 ; i++) {
    17.                 data.printA();
    18.             }
    19.         },"A").start();
    21.         new Thread(()->{
    22.             for (int i = 0; i <10 ; i++) {
    23.                 data.printB();
    24.             }
    25.         },"B").start();
    27.         new Thread(()->{
    28.             for (int i = 0; i <10 ; i++) {
    29.                 data.printC();
    30.             }
    31.         },"C").start();
    32.     }
    34. }
    36. class Data3{ // 资源类 Lock
    38.     private Lock lock = new ReentrantLock();
    39.     private Condition condition1 = lock.newCondition();
    40.     private Condition condition2 = lock.newCondition();
    41.     private Condition condition3 = lock.newCondition();
    42.     private int number = 1; // 1A  2B  3C
    44.     public void printA(){
    45.         System.out.println("A进来了~~~~");
    46.         lock.lock();
    47.         try {
    48.             // 业务，判断-> 执行-> 通知
    49.             while (number!=1){
    50.                 // 等待
    51.                 condition1.await();
    52.             }
    53.             System.out.println(Thread.currentThread().getName()+"=>AAAAAAA");
    54.             // 唤醒，唤醒指定的人，B
    55.             number = 2;
    56.             condition2.signal();
    57.         } catch (Exception e) {
    58.             e.printStackTrace();
    59.         } finally {
    60.             System.out.println("A释放锁完毕");
    61.             lock.unlock();
    62.         }
    63.     }
    65.     public void printB(){
    66.         System.out.println("B进来了~~~~");
    67.         lock.lock();
    68.         try {
    69.             // 业务，判断-> 执行-> 通知
    70.             while (number!=2){
    71.                 condition2.await();
    72.             }
    73.             System.out.println(Thread.currentThread().getName()+"=>BBBBBBBBB");
    74.             // 唤醒，唤醒指定的人，c
    75.             number = 3;
    76.             condition3.signal();
    77.         } catch (Exception e) {
    78.             e.printStackTrace();
    79.         } finally {
    80.             System.out.println("B释放锁完毕");
    81.             lock.unlock();
    82.         }
    83.     }
    84.     public void printC(){
    85.         System.out.println("C进来了~~~~");
    86.         lock.lock();
    87.         try {
    88.             // 业务，判断-> 执行-> 通知
    89.             // 业务，判断-> 执行-> 通知
    90.             while (number!=3){
    91.                 condition3.await();
    92.             }
    93.             System.out.println(Thread.currentThread().getName()+"=>CCCCCCC");
    94.             // 唤醒，唤醒指定的人，c
    95.             number = 1;
    96.             condition1.signal();
    97.         } catch (Exception e) {
    98.             e.printStackTrace();
    99.         } finally {
    100.             System.out.println("C释放锁完毕");
    101.             lock.unlock();
    102.         }
    103.     }
    105. }
    1. B进来了~~~~
    2. A进来了~~~~
    3. C进来了~~~~
    4. A=>AAAAAAA
    5. A释放锁完毕
    6. A进来了~~~~
    7. B=>BBBBBBBBB
    8. B释放锁完毕
    9. B进来了~~~~
    10. C=>CCCCCCC
    11. C释放锁完毕
    12. C进来了~~~~
    13. A=>AAAAAAA
    14. A释放锁完毕
    15. A进来了~~~~
    16. B=>BBBBBBBBB
    17. B释放锁完毕
    18. B进来了~~~~
    19. C=>CCCCCCC
    20. C释放锁完毕
    21. C进来了~~~~
    22. A=>AAAAAAA
    23. A释放锁完毕
    24. A进来了~~~~
    25. B=>BBBBBBBBB
    26. B释放锁完毕
    27. B进来了~~~~
    28. C=>CCCCCCC
    29. C释放锁完毕
    30. C进来了~~~~
    31. A=>AAAAAAA
    32. A释放锁完毕
    33. A进来了~~~~
    34. B=>BBBBBBBBB
    35. B释放锁完毕
    36. B进来了~~~~
    37. C=>CCCCCCC
    38. C释放锁完毕
    39. C进来了~~~~
    40. A=>AAAAAAA
    41. A释放锁完毕
    42. A进来了~~~~
    43. B=>BBBBBBBBB
    44. B释放锁完毕
    45. B进来了~~~~
    46. C=>CCCCCCC
    47. C释放锁完毕
    48. C进来了~~~~
    49. A=>AAAAAAA
    50. A释放锁完毕
    51. A进来了~~~~
    52. B=>BBBBBBBBB
    53. B释放锁完毕
    54. B进来了~~~~
    55. C=>CCCCCCC
    56. C释放锁完毕
    57. C进来了~~~~
    58. A=>AAAAAAA
    59. A释放锁完毕
    60. A进来了~~~~
    61. B=>BBBBBBBBB
    62. B释放锁完毕
    63. B进来了~~~~
    64. C=>CCCCCCC
    65. C释放锁完毕
    66. C进来了~~~~
    67. A=>AAAAAAA
    68. A释放锁完毕
    69. A进来了~~~~
    70. B=>BBBBBBBBB
    71. B释放锁完毕
    72. B进来了~~~~
    73. C=>CCCCCCC
    74. C释放锁完毕
    75. C进来了~~~~
    76. A=>AAAAAAA
    77. A释放锁完毕
    78. A进来了~~~~
    79. B=>BBBBBBBBB
    80. B释放锁完毕
    81. B进来了~~~~
    82. C=>CCCCCCC
    83. C释放锁完毕
    84. C进来了~~~~
    85. A=>AAAAAAA
    86. A释放锁完毕
    87. B=>BBBBBBBBB
    88. B释放锁完毕
    89. C=>CCCCCCC
    90. C释放锁完毕