Java实现三个线程A B C,A线程打印A，之后B线程打印B，接着C线程执行打印C，继而循环下去

此文献给那些被面试题坑了的同志们，至少我被坑过

 

package com.yt.test.thread.rycle;

import java.util.ArrayList;
import java.util.Hashtable;
import java.util.List;
import java.util.Map;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

/**
 * 用于顺序执行循环事务的线程队列
 * @author ChenSS
 */
public class CycleThread {
    private static int index = 0;
    private static Lock sLock = new ReentrantLock();
    private static Map<String, Condition> sConditionMap = new Hashtable<>();
    private static List<Thread> sList = new ArrayList<>();

    private CycleThread() {
    }

    public static void append(CallBack callback, String threadName) {
        Thread thread = create(callback, threadName);
        sList.add(thread);
        sConditionMap.put(thread.getName(), sLock.newCondition());
        System.out.println(sConditionMap);
    }

    private static Thread create(CallBack callback, String threadName) {
        return new Thread(new Runnable() {
            private CallBack call = callback;

            @Override
            public void run() {
                while (true) {
                    try {
                        sLock.lock();
                        Thread node = sList.get(index);
                        if (node.getName().equals(Thread.currentThread().getName())) {
                            call.excute();
                            Thread.sleep(300);
                            index++;
                            if (index == sList.size())
                                index = 0;
                            sConditionMap.get(sList.get(index).getName()).signal();
                        } else {
                            sConditionMap.get(Thread.currentThread().getName()).await();
                        }
                    } catch (Exception ex) {
                        ex.printStackTrace();
                    } finally {
                        sLock.unlock();
                    }
                }
            }
        }, threadName);

    }

    public static void run(int index) {
        CycleThread.index=index;
        for (Thread thread : sList) {
            thread.start();
        }
    }
    
    public static void run() {
        for (Thread thread : sList) {
            thread.start();
        }
    }
    
    interface CallBack {
        public void excute();
    }

    /**
     * 测试用方法
     */
    public static CallBack testCallBack() {
        return () -> System.out.println(Thread.currentThread().getName());
    }

    public static void main(String[] args) {
        CallBack back1 = testCallBack();
        CycleThread.append(back1, "A");
        CallBack back2 = testCallBack(); 
        CycleThread.append(back2, "B");
        CallBack back3 = testCallBack();
        CycleThread.append(back3, "C");
        CycleThread.append(() -> System.out.println("处理特殊事务"), "D");
        CycleThread.run();
    }
}