java多线程面试题：三个线程顺序打印ABC，重复10次

这个面试题，比较经典。有不同的解决思路。有的博文是用Join去实现。我面试的时候也是第一个想到的是用join叫A线程等待B线程执行完再执行。这样的思路能实现，但是不好。虽然当时凑合着说服了面试官。先把代码贴出来

private Thread aThread,bThread,cThread;

@Test
public void test1() {

aThread=new Thread(new Runnable() {

@Override
public void run() {
// TODO Auto-generated method stub
System.out.println("A");
try {
bThread.start();
bThread.join();
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
});
bThread=new Thread(new Runnable() {

@Override
public void run() {
// TODO Auto-generated method stub
System.out.println("B");
try {
cThread.start();
cThread.join();
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
});
cThread=new Thread(new Runnable() {

@Override
public void run() {
// TODO Auto-generated method stub
System.out.println("C");

}
});

aThread.start();

}这个思路比较简单。三个线程。启动a,打印完A后；启动b，打印完B后；启动c。虽然能实现顺序打印，但是会之后还会重复创建线程。这个面试题当时答的貌似有道理，同时跟面试官说了说多线程的知识，面试官还算满意。回来后一考虑，太Low了。然后自己查资料研究了一下。下边把正确答案贴出来
public class MyTest1 {

private static Boolean flagA=true;
private static Boolean flagB=false;
private static Boolean flagC=false;

public static void main(String[] args) {
final Object lock = new Object();

Thread aThread=new Thread(new Runnable() {

@Override
public void run() {
for(int i=0;i<10;) {

synchronized (lock) {

if (flagA) {
//线程A执行
System.out.println("A");
flagA=false;
flagB=true;
flagC=false;
lock.notifyAll();
i++;

}else {
try {
lock.wait();
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}

}
}

}

}
});

Thread bThread=new Thread(new Runnable() {

@Override
public void run() {
for(int i=0;i<10;) {

synchronized (lock) {
if (flagB) {
//线程执行
System.out.println("B");
flagA=false;
flagB=false;
flagC=true;
lock.notifyAll();
i++;

}else {

try {
lock.wait();
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}

}

}

}

}
});

Thread cThread=new Thread(new Runnable() {

@Override
public void run() {
for(int i=0;i<10;) {

synchronized (lock) {

if (flagC) {
//线程执行
System.out.println("C");
flagA=true;
flagB=false;
flagC=false;
lock.notifyAll();
i++;

}else {

try {
lock.wait();
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}

}

}

}

}
});

cThread.start();
bThread.start();
aThread.start();
}

亲测通过。没什么问题。基本思路就是设置三个boolean变量和一个锁。flag控制那个线程可以走，那个应该停下来。然后在打印后才i++。直到i<10的时候，线程停止。
下边在送一个实例。写一个多线程程序，交替输出1,2,1,2,1,2......

public class OutputThread implements Runnable {

private int num;
private Object lock;

public OutputThread(int num, Object lock) {
super();
this.num = num;
this.lock = lock;
}

public void run() {
try {
while(true){
synchronized(lock){
lock.notifyAll();
lock.wait();
System.out.println(num);
}
}
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}

}

public static void main(String[] args){
final Object lock = new Object();

Thread thread1 = new Thread(new OutputThread(1,lock));
Thread thread2 = new Thread(new OutputThread(2, lock));

thread1.start();
thread2.start();
}

}原理一样，关键代码就是
while(true){
synchronized(lock){
lock.notifyAll();
lock.wait();
System.out.println(num);
}
}