有四个线程1、2、3、4，线程1的功能就是输出1，线程2的功能就是输出2，以此类推......... 现在有四个文件A B C D,初始都为空。现要让四个文件呈如下格式：A：1 2 3 4 1 2..

具体题目如下：

有四个线程1、2、3、4，

线程1的功能就是输出1，线程2的功能就是输出2，
以此类推......... 
现在有四个文件A B C D,
初始都为空。现要让四个文件呈如下格式：
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....

以上就是我看到的一个多线程相关的面试题，看完了 ，就想想怎么实现。

下面就看代码

理论上讲，都是从main方法走起，

package com.lxk.threadTest.mianShiTest.googleTest;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

/**
 * 有四个线程1、2、3、4。
 * <p>
 * 线程1的功能就是输出1，线程2的功能就是输出2，
 * <p>
 * 以此类推......... 现在有四个文件A B C D,
 * 初始都为空。现要让四个文件呈如下格式：
 * 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....
 * <p>
 * Created by lxk on 2017/7/14
 */
public class Main {
    public static void main(String[] args) {
        FileWriteUtil util = new FileWriteUtil();
        ExecutorService service = Executors.newCachedThreadPool();
        service.execute(new WriteRunnable(util, 1, '1'));
        service.execute(new WriteRunnable(util, 2, '2'));
        service.execute(new WriteRunnable(util, 3, '3'));
        service.execute(new WriteRunnable(util, 4, '4'));
        service.shutdown();

        //new Thread(new WriteRunnable(util, 1, '1')).start();
        //new Thread(new WriteRunnable(util, 2, '2')).start();
        //new Thread(new WriteRunnable(util, 3, '3')).start();
        //new Thread(new WriteRunnable(util, 4, '4')).start();
    }
}

上面关于启动线程，有2中方式，

第一种，也就是未注释的，略显高级点，看类名大概就知道使用的是个线程池的东西。这个实现姿势有很多种。这只是其中的一个。

第二种，也就是下面注释的代码，也不low，是我们常见的启动线程 的方式。

然后就是我们说的那个实现多线程的类的实现啦

package com.lxk.threadTest.mianShiTest.googleTest;

/**
 * Created by lxk on 2017/7/14
 */
public class WriteRunnable implements Runnable {
    private final FileWriteUtil util;
    private int threadNum;
    private char value;

    /**
     * @param util      写文件工具类
     * @param threadNum 线程号
     * @param value     写的字符
     */
    public WriteRunnable(FileWriteUtil util, int threadNum, char value) {
        this.util = util;
        this.threadNum = threadNum;
        this.value = value;
    }

    public void run() {
        /*
         * 假设循环6次，一直循环可以使用while(true)或者for(;;)
         */
        for (int i = 0; i < 6; i++) {
            synchronized (util) {
                while (threadNum != util.getCurrentThreadNum()) {
                    try {
                        util.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                util.write(value, threadNum);
                util.notifyAll();
            }
        }
    }
}

最后，就是这个写文件的类啦。

package com.lxk.threadTest.mianShiTest.googleTest;

import java.io.FileWriter;
import java.io.IOException;

/**
 * 此类，是四个线程共享的，
 * <p>
 * Created by lxk on 2017/7/14
 */
public class FileWriteUtil {
    private int currentThreadNum = 1;
    /**
     * 记录将字符写入文件的次数
     */
    private int count = 0;

    private String currentFileName;

    public void write(char value, int threadNum) {
        getCurrentFileName();
        FileWriter writer = null;
        try {
            //生成文件位置
            writer = new FileWriter("D:/test/test/" + currentFileName + ".txt", true);
            writer.write(value + " ");
            System.out.printf(
                    "ThreadNum=%d is executing. %c is written into file file%s.txt \n",
                    currentThreadNum, value, currentFileName);
            writer.flush();
            //System.out.println(count);//
            count++;
            currentThreadNum = threadNum;
        } catch (IOException e) {
            e.printStackTrace();
        }

        if (null != writer) {
            try {
                writer.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        getNextThreadNum();
    }

    public int getCurrentThreadNum() {
        return currentThreadNum;
    }

    public void setCurrentThreadNum(int currentThreadNum) {
        this.currentThreadNum = currentThreadNum;
    }

    /**
     * 根据写的次数，判断该写哪个文件了？A，B,C,D.
     */
    private void getCurrentFileName() {
        int temp = count % 4;
        switch (temp) {
            case 0:
                currentFileName = "A";
                break;
            case 1:
                currentFileName = "B";
                break;
            case 2:
                currentFileName = "C";
                break;
            case 3:
                currentFileName = "D";
                break;
            default:
                currentFileName = "E";
        }
    }

    private void getNextThreadNum() {
        if (count % 4 == 0) {
            if (currentThreadNum < 3) {
                currentThreadNum += 2;
            } else {
                currentThreadNum = (currentThreadNum + 2) % 4;
            }
        } else {
            if (currentThreadNum == 4) {
                currentThreadNum = 1;
            } else {
                currentThreadNum++;
            }
        }
    }
}

最后，就是看下代码实际运行的结果。

从打印结果看，看到了是四个线程在跑，而且分别写入到ABCD四个文件去。

注意，图中的红线框，奥，也可以不注意啦。

其实，说得最透彻点，就是这四个线程，轮着执行，

每次，都是有一个线程可以执行，这的执行也就是写文件啦，然后其他的三个都稍息，也是wait()啦。

等这个线程执行完毕之后，也就是写文件完毕之后，唤醒另外三个在wait()的线程，然后，设置一下，下一个可以处于运行态的线程，然后又开始重复了。

不能执行的，都wait()，如此往复。

这里有个需要注意的是。

这四个线程都在共享操作的就是那个写文件工具类。也就是对这个上锁。四个线程用的是一个锁，那就可以保证线程安全啦。

理论，是这个理论，但是，真让你写，可不一定能分分钟就写好。