ABCABCABCABCABC

/*
 1.設(shè)置共享變量state控制線程的執(zhí)行順序
 2.在打印方法中傳入兩個(gè)參數(shù)：打印的內(nèi)容， 當(dāng)前線程的state
 3.每個(gè)線程在調(diào)用打印方法時(shí)都要傳入自己對(duì)應(yīng)的順序，A：0，B：1，C：2
*/
public class PrintABC {
    private static int state = 0;// 設(shè)置共享變量控制線程執(zhí)行順序
    private static final int COUNT = 5;// 控制執(zhí)行順序
    private static Object lock = new Object();// 用于加鎖的對(duì)象

    public static void main(String[] args) {
        Thread t1 = new Thread(() -> {
            try {
                printChar("A", 0);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
        });
        Thread t2 = new Thread(() -> {
            try {
                printChar("B", 1);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
        });
        Thread t3 = new Thread(() -> {
            try {
                printChar("C", 2);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
        });

        t1.start();
        t2.start();
        t3.start();
    }

    private static void printChar(String name, int curState) throws InterruptedException {
        int i = 0;
        while(i < COUNT) {
            synchronized (lock) {
                if(state % 3 == curState) {// 是當(dāng)前線程的執(zhí)行順序
                    System.out.print(name + " ");
                    i++;// 控制當(dāng)前線程的執(zhí)行的次數(shù)
                    state++;// 輪轉(zhuǎn)到下一個(gè)線程
                    lock.notifyAll();
                }else {// 輪不到當(dāng)前線程  wait等待
                    lock.wait();
                }
            }
        }
    }
}

    /*
     *第四種方法：ReentrantLock + Condition 來(lái)實(shí)現(xiàn)更加精確的線程間通信
     * ReentrantLock實(shí)現(xiàn)加鎖，解鎖； Condition實(shí)現(xiàn)線程間的通信
     */

    public static final int COUNT = 5;
    public static int state = 0;
    public static ReentrantLock lock = new ReentrantLock();
    public static Condition conA = lock.newCondition();
    public static Condition conB = lock.newCondition();
    public static Condition conC = lock.newCondition();

    public static void main(String[] args) {
        new Thread(() ->printChar("A", 0, conA, conB)).start();
        new Thread(() ->printChar("B", 1, conB, conC)).start();
        new Thread(() ->printChar("C", 2, conC, conA)).start();
    }

    private static void printChar(String name, int curState, Condition curCondition, Condition nextCondition) {
        for(int i = 0; i < COUNT; i++) {
            lock.lock();
                try {
                    while(state % 3 != curState)
                        curCondition.await();

                    // 是當(dāng)前線程  執(zhí)行
                    System.out.print(name);
                    state++;
                    nextCondition.signal();

                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }finally {
                    lock.unlock();
                }

        }
    }

    /*
     * 第二種方法：使用Semaphore 信號(hào)量的方式控制執(zhí)行順序
     * 如何保證先打印A：semA, semB, semC  將A的許可設(shè)置為1，B,C的許可設(shè)置為0，則一定先執(zhí)行A
     * 如何保證打印順序：在打印方法中傳入三個(gè)參數(shù)：name， curSem, nextSem  A-B  B-C  C-A
     * 執(zhí)行完當(dāng)前線程打印內(nèi)容之后，讓下一個(gè)線程release一個(gè)許可
     */

    private static final Semaphore semA = new Semaphore(1);
    private static final Semaphore semB = new Semaphore(0);
    private static final Semaphore semC = new Semaphore(0);
    private static final int COUNT = 5;

    public static void main(String[] args) {
        new Thread(() -> printChar("A", semA, semB)).start();
        new Thread(() -> printChar("B", semB, semC)).start();
        new Thread(() -> printChar("C", semC, semA)).start();
    }

    private static void printChar(String name, Semaphore cur, Semaphore next) {
        for(int i = 0; i < COUNT;) {
            try {
                cur.acquire();
                System.out.print(name + " ");
                ++i;
                next.release();
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
        }
    }

    /*
     * 第三種方法：使用BlockingQueue作為令牌的方式來(lái)控制打印順序
     * 創(chuàng)建三個(gè)隊(duì)列，每個(gè)隊(duì)列分別打印對(duì)應(yīng)需要打印的內(nèi)容
     * 使用令牌來(lái)控制打印的順序，和使用semaphore類(lèi)似
     * 在打印的方法中傳入三個(gè)參數(shù)：要打印的內(nèi)容，當(dāng)前隊(duì)列，下一個(gè)隊(duì)列
     */

    public static BlockingQueue<String> qA = new ArrayBlockingQueue<>(1);
    public static BlockingQueue<String> qB = new ArrayBlockingQueue<>(1);
    public static BlockingQueue<String> qC = new ArrayBlockingQueue<>(1);
    public static final int COUNT = 5;

    public static void main(String[] args) throws InterruptedException {
        new Thread(() -> printChar("A", qA, qB)).start();
        new Thread(() -> printChar("B", qB, qC)).start();
        new Thread(() -> printChar("C", qC, qA)).start();

        qA.put("go");
    }

    private static void printChar(String name, BlockingQueue<String> curQueue, BlockingQueue<String> nextQueue) {
        for(int i = 0; i < COUNT; i++) {
            try {
                curQueue.take();// 等待令牌傳遞
                System.out.print(name + " ");
                nextQueue.put("go");// 傳遞令牌
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
        }
    }