用java传统线程方式实现多线程轮询执行问题

最近在学习复习java多线程方面的知识，看到一道多线程方面问题。主线程执行三次，然后子线程1执行三次，最后子线程2执行三次，按照这样的规则循环执行10次。一开始使用Lock和Condition两个类来实现功能。因为一个锁可以创建多个Condition，每个线程拥有一个自己的Condition，通过某个线程的Condition唤醒特定线程，很容易就能实现需求。具体代码如下：

public class ThreeConditionTest {

	
	public static void main(String[] args) {
		final Outer outer=new Outer();
		new Thread(new Runnable(){
			@Override
			public void run() {
				// TODO Auto-generated method stub
				for(int i=0;i<10;i++){
					outer.main(i);
				}
			}
		}).start();
		new Thread(new Runnable(){
			@Override
			public void run() {
				// TODO Auto-generated method stub
				for(int i=0;i<10;i++){
					outer.sub1(i);
				}
			}
		}).start();
		new Thread(new Runnable(){
			@Override
			public void run() {
				// TODO Auto-generated method stub
				for(int i=0;i<10;i++){
					outer.sub2(i);
				}
			}
		}).start();
	
	}
	
	static class Outer{
		Lock lock = new ReentrantLock();
		Condition mainCondition = lock.newCondition();
		Condition sub1Condition = lock.newCondition();
		Condition sub2Condition = lock.newCondition();
		int flag=1;
		
		public void main(int i){
			lock.lock();
			try{
				if(flag != 1){
					try {
						mainCondition.await();
					} catch (InterruptedException e) {
						// TODO Auto-generated catch block
						e.printStackTrace();
					}
				}
				for(int j=0;j<3;j++){
					System.out.println("main thread "+(j+1)+" 次"+" loop of "+(i+1));
				}
				flag = 2;
				sub1Condition.signal();
			}finally{
				lock.unlock();
			}
		}
		
		public void sub1(int i){
			lock.lock();
			try{
				if(flag != 2){
					try {
						sub1Condition.await();
					} catch (InterruptedException e) {
						// TODO Auto-generated catch block
						e.printStackTrace();
					}
				}
				for(int j=0;j<3;j++){
					System.out.println("sub1 thread "+(j+1)+" 次"+" loop of "+(i+1));
				}
				flag=3;
				sub2Condition.signal();
			}finally{
				lock.unlock();
			}
		}
		
		public void sub2(int i){
			lock.lock();
			try{
				if(flag != 3){
					try {
						sub2Condition.await();
					} catch (InterruptedException e) {
						// TODO Auto-generated catch block
						e.printStackTrace();
					}
				}
				for(int j=0;j<3;j++){
					System.out.println("sub2 thread "+(j+1)+" 次"+" loop of "+(i+1));
				}
				flag = 1;
				mainCondition.signal();
			}finally{
				lock.unlock();
			}
		}
		
	}
}

java传统同步方法（synchronized）提供notify（）和notifyAll（）两个常用的多线程之间通信方式，但是这两个方法都不能唤醒某个指定的线程，只能随机唤醒一个或者全部唤醒，这就使得让多线程按照我们的要求来执行变得没那么容易，而java5的锁可以指定唤醒某个线程，这使得我们编写此类多线程轮训执行的问题变得很简单。今天复习的时候突然想试一下用传统线程实现。

代码如下：

public class ThreeWaitTest {

	public static void main(String[] args) {
		final Outer outer=new Outer();
		new Thread(new Runnable(){
			@Override
			public void run() {
				// TODO Auto-generated method stub
				for(int i=0;i<5;i++){
					outer.main(i);
				}
			}
		}).start();
		new Thread(new Runnable(){
			@Override
			public void run() {
				// TODO Auto-generated method stub
				for(int i=0;i<5;i++){
					outer.sub1(i);
				}
			}
		}).start();
		new Thread(new Runnable(){
			@Override
			public void run() {
				// TODO Auto-generated method stub
				for(int i=0;i<5;i++){
					outer.sub2(i);
				}
			}
		}).start();
	
	}
	
	static class Outer{
		
		static	int flag=1;
		public synchronized void main(int i){
			
			if(flag != 1){
					try {
						this.wait();
					} catch (InterruptedException e) {
						// TODO Auto-generated catch block
						e.printStackTrace();
					}
				}
				
				for(int j=0;j<3;j++){
					System.out.println("main thread "+(j+1)+" 次"+" loop of "+(i+1));
				}
				
				flag = 2;
				this.notifyAll();
			
		}
		
		public synchronized void sub1(int i){
			if(flag != 2){
					try {
						this.wait();
					} catch (InterruptedException e) {
						// TODO Auto-generated catch block
						e.printStackTrace();
					}
				}
				for(int j=0;j<3;j++){
					System.out.println("sub1 thread "+(j+1)+" 次"+" loop of "+(i+1));
				}
				flag=3;
				this.notifyAll();
		}
		
		public synchronized void sub2(int i){
				if(flag != 3){
					try {
						this.wait();
					} catch (InterruptedException e) {
						// TODO Auto-generated catch block
						e.printStackTrace();
					}
				}
				for(int j=0;j<3;j++){
					System.out.println("sub2 thread "+(j+1)+" 次"+" loop of "+(i+1));
				}
				flag = 1;
				this.notifyAll();
		}
		
	}
}

实现起来貌似并没有那么难，而且代码看起来完全没问题。但是执行的结果却意外的出错了，于是来回检查代码，完全找不到错误所在。苦思冥想一上午，想着是否传统线程就实现不了三个及以上的多线程之间通信，正当打算放弃的时候，突然想起了以前无意中看到的关于线程假唤醒的问题。于是把判断线程是否该进入等待状态的if语句换成了while语句。没想到最后真的成功了。最后在此提醒大家一句也是提醒一下自己。在多线程编程中，判断条件尽量用while，因为while是表达循环语句，只要不满足条件就会一直循环下去，不会发生假唤醒状况，而if仅仅是一个判断语句