1. public class Test1 {
    3.     public static void main(String[] args) throws Exception {
    4.         Object a = new Object();
    5.         Object b = new Object();
    6.         Object c = new Object();
    8.         new Thread(new MyRunnable("A", c, a)).start();
    9.         Thread.sleep(100);
    10.         new Thread(new MyRunnable("B", a, b)).start();
    11.         Thread.sleep(100);
    12.         new Thread(new MyRunnable("C", b, c)).start();
    13.     }
    14. }
    16. class MyRunnable implements Runnable {
    17.     private String name;
    18.     private Object prev;
    19.     private Object cur;
    21.     public MyRunnable(String name, Object prev, Object cur) {
    22.         this.name = name;
    23.         this.prev = prev;
    24.         this.cur = cur;
    25.     }
    27.     @Override
    28.     public void run() {
    29.         int count = 10;
    30.         while (count > 0) {
    31.             synchronized (prev) {
    32.                 synchronized (cur) {
    33.                     System.out.print(name);
    34.                     count--;
    35.                     cur.notifyAll();
    36.                 }
    37.                 if (count != 0) {
    38.                     try {
    39.                         prev.wait();
    40.                     } catch (InterruptedException e) {
    41.                         e.printStackTrace();
    42.                     }
    43.                 }
    44.             }
    45.         }
    46.     }
    47. }
    1. public class Test1 {
    3.     private static volatile int state = 0;
    5.     static class ThreadA extends Thread {
    6.         @Override
    7.         public void run() {
    8.             int i = 0;
    9.             while (i < 10) {
    10.                 if (state % 3 == 0) {
    11.                     System.out.print("A");
    12.                     state++;
    13.                     i++;
    14.                 }
    15.             }
    16.         }
    17.     }
    19.     static class ThreadB extends Thread {
    20.         @Override
    21.         public void run() {
    22.             int i = 0;
    23.             while (i < 10) {
    24.                 if (state % 3 == 1) {
    25.                     System.out.print("B");
    26.                     state++;
    27.                     i++;
    28.                 }
    29.             }
    30.         }
    31.     }
    33.     static class ThreadC extends Thread {
    34.         @Override
    35.         public void run() {
    36.             int i = 0;
    37.             while (i < 10) {
    38.                 if (state % 3 == 2) {
    39.                     System.out.print("C");
    40.                     state++;
    41.                     i++;
    42.                 }
    43.             }
    44.         }
    45.     }
    47.     public static void main(String[] args) {
    48.         new ThreadA().start();
    49.         new ThreadB().start();
    50.         new ThreadC().start();
    51.     }
    52. }
    1. public class Test1 {
    3.     private static Lock lock = new ReentrantLock();
    4.     private static Condition A = lock.newCondition();
    5.     private static Condition B = lock.newCondition();
    6.     private static Condition C = lock.newCondition();
    7.     private static int count = 0;
    9.     static class ThreadA extends Thread {
    10.         @Override
    11.         public void run() {
    12.             try {
    13.                 lock.lock();
    14.                 for (int i = 0; i < 10; i++) {
    15.                     while (count % 3 != 0)
    16.                         A.await();
    17.                     System.out.print("A");
    18.                     count++;
    19.                     B.signal();
    20.                 }
    21.             } catch (Exception e) {
    22.                 e.printStackTrace();
    23.             } finally {
    24.                 lock.unlock();
    25.             }
    26.         }
    27.     }
    29.     static class ThreadB extends Thread {
    30.         @Override
    31.         public void run() {
    32.             try {
    33.                 lock.lock();
    34.                 for (int i = 0; i < 10; i++) {
    35.                     while (count % 3 != 1)
    36.                         B.await();
    37.                     System.out.print("B");
    38.                     count++;
    39.                     C.signal();
    40.                 }
    41.             } catch (Exception e) {
    42.                 e.printStackTrace();
    43.             } finally {
    44.                 lock.unlock();
    45.             }
    46.         }
    47.     }
    48.     static class ThreadC extends Thread {
    49.         @Override
    50.         public void run() {
    51.             try {
    52.                 lock.lock();
    53.                 for (int i = 0; i < 10; i++) {
    54.                     while (count % 3 != 2)
    55.                         C.await();
    56.                     System.out.print("C");
    57.                     count++;
    58.                     A.signal();
    59.                 }
    60.             } catch (Exception e) {
    61.                 e.printStackTrace();
    62.             } finally {
    63.                 lock.unlock();
    64.             }
    65.         }
    66.     }
    68.     public static void main(String[] args) {
    69.         new ThreadA().start();
    70.         new ThreadB().start();
    71.         new ThreadC().start();
    72.     }
    74. }
    1. public class Test1 {
    3.     private static Semaphore A = new Semaphore(1);
    4.     private static Semaphore B = new Semaphore(0);
    5.     private static Semaphore C = new Semaphore(0);
    7.     static class ThreadA extends Thread {
    8.         @SneakyThrows
    9.         @Override
    10.         public void run() {
    11.             for (int i = 0; i < 10; i++) {
    12.                 A.acquire();
    13.                 System.out.print("A");
    14.                 B.release();
    15.             }
    16.         }
    17.     }
    19.     static class ThreadB extends Thread {
    20.         @SneakyThrows
    21.         @Override
    22.         public void run() {
    23.             for (int i = 0; i < 10; i++) {
    24.                 B.acquire();
    25.                 System.out.print("B");
    26.                 C.release();
    27.             }
    28.         }
    29.     }
    31.     static class ThreadC extends Thread {
    32.         @SneakyThrows
    33.         @Override
    34.         public void run() {
    35.             for (int i = 0; i < 10; i++) {
    36.                 C.acquire();
    37.                 System.out.println("C");
    38.                 A.release();
    39.             }
    40.         }
    41.     }
    43.     public static void main(String[] args) {
    44.         new ThreadA().start();
    45.         new ThreadB().start();
    46.         new ThreadC().start();
    47.     }
    49. }