有四个线程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()，如此往复。

这里有个需要注意的是。

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

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