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);
                }
            }