package thread;

import java.io.File;
import java.io.FileWriter;
import java.io.IOException;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.ReentrantLock;

/**
 * @Author: wei1
 * @Date: Create in 2018/10/11 20:47
 * @Description: 有四个线程1、2、3、4。线程1的功能就是输出1，线程2的功能就是输出2，以此类推。
 * 现在有四个文件ABCD。初始都为空。现要让四个文件呈如下格式：
 * A. 1 2 3 4 1 2....
 * B. 2 3 4 1 2 3....
 * C. 3 4 1 2 3 4....
 * D. 4 1 2 3 4 1....
 * 请设计程序。
 * 4个线程同时执行，每个负责向文件输出1 2 3 4
 * 就是线程1向Ａ B C D 四个文件输出1
 * 就是线程2向Ａ B C D 四个文件输出2
 * 就是线程3向Ａ B C D 四个文件输出3
 * 就是线程4向Ａ B C D 四个文件输出4
 * 开始就是用Reentrant的一个锁对应多个condition来控制流程，但是这样是一个线程在写，3个在等没有意义
 * 现在发现这个是有执行顺序的,注意每个IO完成的时间都不一样，注意sleep一会
 * 线程1： A -> D -> C -> B
 * 线程2： B -> A -> D -> C
 * 线程3： C -> B -> A -> D
 * 线程4： D -> C -> B -> A
 */
public class ThreadOrderRun5 {
    File fileA = new File("A.txt");
    File fileB = new File("B.txt");
    File fileC = new File("C.txt");
    File fileD = new File("D.txt");
    FileWriter fwA;
    FileWriter fwB;
    FileWriter fwC;
    FileWriter fwD;
    volatile int fileAid = 1;
    volatile int fileBid = 2;
    volatile int fileCid = 3;
    volatile int fileDid = 4;
    ReentrantLock lockA = new ReentrantLock();
    ReentrantLock lockB = new ReentrantLock();
    ReentrantLock lockC = new ReentrantLock();
    ReentrantLock lockD = new ReentrantLock();
    Condition conditionA1 = lockA.newCondition();
    Condition conditionA2 = lockA.newCondition();
    Condition conditionA3 = lockA.newCondition();
    Condition conditionA4 = lockA.newCondition();

    Condition conditionB1 = lockB.newCondition();
    Condition conditionB2 = lockB.newCondition();
    Condition conditionB3 = lockB.newCondition();
    Condition conditionB4 = lockB.newCondition();

    Condition conditionC1 = lockC.newCondition();
    Condition conditionC2 = lockC.newCondition();
    Condition conditionC3 = lockC.newCondition();
    Condition conditionC4 = lockC.newCondition();

    Condition conditionD1 = lockD.newCondition();
    Condition conditionD2 = lockD.newCondition();
    Condition conditionD3 = lockD.newCondition();
    Condition conditionD4 = lockD.newCondition();

    CountDownLatch start = new CountDownLatch(1);

    public ThreadOrderRun5() throws IOException {
        //初始化创建文件A Ｂ C D
        if (fileA.exists() || fileB.exists() || fileC.exists() || fileD.exists()) {
            fileA.delete();
            fileB.delete();
            fileC.delete();
            fileD.delete();
        }
        fileA.createNewFile();
        fileB.createNewFile();
        fileC.createNewFile();
        fileD.createNewFile();
        fwA = new FileWriter(fileA);
        fwB = new FileWriter(fileB);
        fwC = new FileWriter(fileC);
        fwD = new FileWriter(fileD);
    }

    private void firstRun(String str) throws IOException, InterruptedException {
        start.await();
        while (true) {
            lockA.lock();
            try {
                while (fileAid != 1) {
                    conditionA1.await();
                }
                fileWriter("fileA", str);
                fileAid = 2;
                conditionA2.signal();
            } finally {
                lockA.unlock();
            }

            lockD.lock();
            try {
                while (fileDid != 1) {
                    conditionD1.await();
                }
                fileWriter("fileD", str);
                fileDid = 2;
                conditionD2.signal();
            } finally {
                lockD.unlock();
            }

            lockC.lock();
            try {
                while (fileCid != 1) {
                    conditionC1.await();
                }
                fileWriter("fileC", str);
                fileCid = 2;
                conditionC2.signal();
            } finally {
                lockC.unlock();
            }

            lockB.lock();
            try {
                while (fileBid != 1) {
                    conditionB1.await();
                }
                fileWriter("fileB", str);
                fileBid = 2;
                conditionB2.signal();
            } finally {
                lockB.unlock();
            }

        }

    }

    private void secondRun(String str) throws IOException, InterruptedException {
        start.await();
        while (true) {
            lockB.lock();
            try {
                while (fileBid != 2) {
                    conditionB2.await();
                }
                fileWriter("fileB", str);
                fileBid = 3;
                conditionB3.signal();
            } finally {
                lockB.unlock();
            }

            lockA.lock();
            try {
                while (fileAid != 2) {
                    conditionA2.await();
                }
                fileWriter("fileA", str);
                fileAid = 3;
                conditionA3.signal();
            } finally {
                lockA.unlock();
            }

            lockD.lock();
            try {
                while (fileDid != 2) {
                    conditionD2.await();
                }
                fileWriter("fileD", str);
                fileDid = 3;
                conditionD3.signal();
            } finally {
                lockD.unlock();
            }

            lockC.lock();
            try {
                while (fileCid != 2) {
                    conditionC2.await();
                }
                fileWriter("fileC", str);
                fileCid = 3;
                conditionC3.signal();
            } finally {
                lockC.unlock();
            }

        }
    }

    private void thirdRun(String str) throws IOException, InterruptedException {
        start.await();
        while (true) {
            lockC.lock();
            try {
                while (fileCid != 3) {
                    conditionC3.await();
                }
                fileWriter("fileC", str);
                fileCid = 4;
                conditionC4.signal();
            } finally {
                lockC.unlock();
            }

            lockB.lock();
            try {
                while (fileBid != 3) {
                    conditionB3.await();
                }
                fileWriter("fileB", str);
                fileBid = 4;
                conditionB4.signal();
            } finally {
                lockB.unlock();
            }

            lockA.lock();
            try {
                while (fileAid != 3) {
                    conditionA3.await();
                }
                fileWriter("fileA", str);
                fileAid = 4;
                conditionA4.signal();
            } finally {
                lockA.unlock();
            }

            lockD.lock();
            try {
                while (fileDid != 3) {
                    conditionD3.await();
                }
                fileWriter("fileD", str);
                fileDid = 4;
                conditionD4.signal();
            } finally {
                lockD.unlock();
            }

        }
    }

    private void fourthRun(String str) throws IOException, InterruptedException {
        start.await();
        while (true) {
            lockD.lock();
            try {
                while (fileDid != 4) {
                    conditionD4.await();
                }
                fileWriter("fileD", str);
                fileDid = 1;
                conditionD1.signal();
            } finally {
                lockD.unlock();
            }

            lockC.lock();
            try {
                while (fileCid != 4) {
                    conditionC4.await();
                }
                fileWriter("fileC", str);
                fileCid = 1;
                conditionC1.signal();
            } finally {
                lockC.unlock();
            }

            lockB.lock();
            try {
                while (fileBid != 4) {
                    conditionB4.await();
                }
                fileWriter("fileB", str);
                fileBid = 1;
                conditionB1.signal();
            } finally {
                lockB.unlock();
            }

            lockA.lock();
            try {
                while (fileAid != 4) {
                    conditionA4.await();
                }
                fileWriter("fileA", str);
                fileAid = 1;
                conditionA1.signal();
            } finally {
                lockA.unlock();
            }

        }
    }


    private void fileWriter(String fileName, String str) throws IOException {
        if (fileName == null) {
            return;
        }
        if (fileName.equals("fileA")) {
            fwA.write(str);
            fwA.flush();
        }
        if (fileName.equals("fileB")) {
            fwB.write(str);
            fwB.flush();
        }
        if (fileName.equals("fileC")) {
            fwC.write(str);
            fwC.flush();
        }
        if (fileName.equals("fileD")) {
            fwD.write(str);
            fwD.flush();
        }
    }

    public static void main(String[] args) throws IOException {
        ThreadOrderRun5 threadOrderRun5 = new ThreadOrderRun5();
        new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    threadOrderRun5.firstRun("1 ");
                } catch (IOException e) {
                    e.printStackTrace();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }).start();
        new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    threadOrderRun5.secondRun("2 ");
                } catch (IOException e) {
                    e.printStackTrace();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }).start();
        new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    threadOrderRun5.thirdRun("3 ");
                } catch (IOException e) {
                    e.printStackTrace();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }).start();
        new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    threadOrderRun5.fourthRun("4 ");
                } catch (IOException e) {
                    e.printStackTrace();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }).start();

        threadOrderRun5.start.countDown();
    }
}