每日算法--多线程顺序执行

/**
 问题描述：有4个线程和1个公共的字符数组。线程1的功能就是向数组输出A，线程2的功能就是向字符输出B，线程3的功能就是向数组输出C，线程4的功能就是向数组输出D。
 要求按顺序向数组赋值ABCDABCDABCD，ABCD的个数由线程函数1的参数指定。[注：C语言选手可使用WINDOWS SDK库函数]
 接口说明：
 线程1,2,3,4按顺序向该数组赋值。

 输入描述:
 本题含有多个样例输入。
 输入一个int整数

 输出描述:
 对于每组样例，输出多个ABCD

 */
public class HJ49 {

    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        while(scanner.hasNextLine()) {
            String count = scanner.nextLine();
            Task task = new Task(Integer.parseInt(count));
           // task.init();
            task.init1();
        }
        scanner.close();
    }
}


class Task{
    private int n;
    private final  LinkedList<Character> arr = new LinkedList<Character>();
    public Task(int n){
        this.n = n;
    }

    public void init(){
        CountDownLatch latch = new CountDownLatch(n);
        try {
            WriteThread write = new WriteThread(arr,latch,n);
            write.start();
            latch.await();
        } catch (Exception e) {
            e.printStackTrace();
            latch.notifyAll();
        }
        System.out.println("result"+arr);
    }

    public void init1(){
        CountDownLatch latch = new CountDownLatch(n);
        try {
            WriteThread1 write = new WriteThread1(arr,latch,n);
            write.start();
            latch.await();
        } catch (Exception e) {
            e.printStackTrace();
            latch.notifyAll();
        }
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("result"+arr);
    }
}

//计数器实现
class WriteThread extends Thread {
    private  LinkedList<Character> arr;
    protected int n;
    CountDownLatch latch;
    public WriteThread(LinkedList arr,CountDownLatch latch,int n){
        this.arr = arr;
        this.latch = latch;
        this.n = n;
    }
    @Override
    public void run() {
        CountDownLatch latch1 ;
        CountDownLatch latch2 ;
        CountDownLatch latch3 ;
        CountDownLatch latch4 ;
        AppendThread t1;
        AppendThread t2;
        AppendThread t3;
        AppendThread t4;
        while (n>0){
            n = n -1 ;
            try {
                latch1 = new CountDownLatch(1);
                t1 = new AppendThread(arr,'A',latch1);
                latch2 = new CountDownLatch(1);
                t2 = new AppendThread(arr,'B',latch2);
                latch3 = new CountDownLatch(1);
                t3 = new AppendThread(arr,'C',latch3);
                latch4 = new CountDownLatch(1);
                t4 = new AppendThread(arr,'D',latch4);
                t1.start();
                latch1.await();
                t2.start();
                latch2.await();
                t3.start();
                latch3.await();
                t4.start();
                latch4.await();
            } catch (Exception e) {
                e.printStackTrace();
            }
            latch.countDown();
        }
    }
}

class AppendThread extends Thread {
    private  LinkedList<Character> arr;
    private  char c ;
    CountDownLatch latch;
    public AppendThread(LinkedList arr, char c,CountDownLatch latch){
        this.arr = arr;
        this.c = c;
        this.latch = latch;
    }
    @Override
    public void run() {
        arr.add(c);
        latch.countDown();
    }
}

//线程池实现(计数器没法控制线程池的提交)
class WriteThread1 extends Thread {
    private  LinkedList<Character> arr;
    protected int n;
    CountDownLatch latch;
    ExecutorService executorService = Executors.newSingleThreadExecutor();
    public WriteThread1(LinkedList arr,CountDownLatch latch,int n){
        this.arr = arr;
        this.n = n;
        this.latch =latch;
    }
    @Override
    public void run() {
        AppendThread1 t1;
        AppendThread1 t2;
        AppendThread1 t3;
        AppendThread1 t4;
        while (n>0){
            n = n -1 ;
            try {
                t1 = new AppendThread1(arr,'A');
                t2 = new AppendThread1(arr,'B');
                t3 = new AppendThread1(arr,'C');
                t4 = new AppendThread1(arr,'D');
                executorService.submit(t1);
                executorService.submit(t2);
                executorService.submit(t3);
                executorService.submit(t4);
            } catch (Exception e) {
                e.printStackTrace();
            }
            latch.countDown();
        }
    }
}

class AppendThread1 extends Thread {
    private  LinkedList<Character> arr;
    private  char c ;
    public AppendThread1(LinkedList arr, char c){
        this.arr = arr;
        this.c = c;
    }
    @Override
    public void run() {
        arr.add(c);
    }
}