1. package cn.itcast.pattern;
    3. import java.util.Arrays;
    4. import java.util.concurrent.locks.Condition;
    5. import java.util.concurrent.locks.LockSupport;
    6. import java.util.concurrent.locks.ReentrantLock;
    8. class SyncWaitNotify {
    9.     private int flag;
    10.     private int loopNumber;
    12.     public SyncWaitNotify(int flag, int loopNumber) {
    13.         this.flag = flag;
    14.         this.loopNumber = loopNumber;
    15.     }
    17.     public void print(int waitFlag, int nextFlag, String str) {
    18.         for (int i = 0; i < loopNumber; i++) {
    19.             synchronized (this) {
    20.                 while (this.flag != waitFlag) {
    21.                     try {
    22.                         this.wait();
    23.                     } catch (InterruptedException e) {
    24.                         e.printStackTrace();
    25.                     }
    26.                 }
    27.                 System.out.print(str);
    28.                 flag = nextFlag;
    29.                 this.notifyAll();
    30.             }
    31.         }
    32.     }
    33. }
    35. class SyncLock extends ReentrantLock {
    36.     Condition waitSet = this.newCondition();
    37.     private int flag;
    38.     private int loopNumber;
    40.     public SyncLock(int flag, int loopNumber) {
    41.         this.flag = flag;
    42.         this.loopNumber = loopNumber;
    43.     }
    45.     public void print(int waitFlag, int nextFlag, String str) {
    46.         for (int i = 0; i < loopNumber; i++) {
    47.             this.lock();
    48.             try {
    49.                 while (this.flag != waitFlag) {
    50.                     try {
    51.                         waitSet.await();
    52.                     } catch (InterruptedException e) {
    53.                         e.printStackTrace();
    54.                     }
    55.                 }
    56.                 System.out.print(str);
    57.                 this.flag = nextFlag;
    58.                 waitSet.signalAll();
    59.             } finally {
    60.                 this.unlock();
    61.             }
    62.         }
    63.     }
    64. }
    66. class SyncPark {
    67.     private int loopNumber;
    68.     private Thread[] threads;
    70.     public SyncPark(int loopNumber) {
    71.         this.loopNumber = loopNumber;
    72.     }
    74.     public void setThreads(Thread... threads) {
    75.         this.threads = threads;
    76.     }
    78.     public void print(String str) {
    79.         for (int i = 0; i < loopNumber; i++) {
    80.             LockSupport.park();
    81.             System.out.print(str);
    82.             LockSupport.unpark(nextThread());
    83.         }
    84.     }
    86.     private Thread nextThread() {
    87.         Thread current = Thread.currentThread();
    88.         int index = 0;
    89.         for (int i = 0; i < threads.length; i++) {
    90.             if(threads[i] == current) {
    91.                 index = i;
    92.                 break;
    93.             }
    94.         }
    95.         if(index < threads.length - 1) {
    96.             return threads[index+1];
    97.         } else {
    98.             return threads[0];
    99.         }
    100.     }
    102.     public void start() {
    103.         for (Thread thread : threads) {
    104.             thread.start();
    105.         }
    106.         LockSupport.unpark(threads[0]);
    107.     }
    108. }
    112. public class TestOrder {
    114.     public static void main(String[] args) {
    115.         test3();
    116.     }
    118.     private static void test3() {
    119.         SyncPark syncPark = new SyncPark(3);
    120.         Thread t1 = new Thread(() -> {
    121.             syncPark.print("a");
    122.         });
    123.         Thread t2 = new Thread(() -> {
    124.             syncPark.print("b");
    125.         });
    126.         Thread t3 = new Thread(() -> {
    127.             syncPark.print("c\n");
    128.         });
    129.         syncPark.setThreads(t1, t2, t3);
    130.         syncPark.start();
    131.     }
    133.     private static void test2() {
    134.         SyncLock syncLock = new SyncLock(1, 5);
    135.         new Thread(() -> {
    136.             syncLock.print(1, 2, "a");
    137.         }).start();
    138.         new Thread(() -> {
    139.             syncLock.print(2, 3, "b");
    140.         }).start();
    141.         new Thread(() -> {
    142.             syncLock.print(3, 1, "c\n");
    143.         }).start();
    144.     }
    146.     private static void test1() {
    147.         SyncWaitNotify syncWaitNotify = new SyncWaitNotify(1, 5);
    148.         new Thread(() -> {
    149.             syncWaitNotify.print(1, 2, "a");
    150.         }).start();
    151.         new Thread(() -> {
    152.             syncWaitNotify.print(2, 3, "b");
    153.         }).start();
    154.         new Thread(() -> {
    155.             syncWaitNotify.print(3, 1, "c\n");
    156.         }).start();
    157.     }
    159. }