【多线程】传统 -- 同步

        上一篇博客总结了多线程运行过程中最基本的一个特性“互斥”之后，昨天学习了“同步”的概念，结合之前学习过的“事务”的概念，“互斥”很像是事务当中的“原子性”，而“同步”很像事务中的一致性，和之前的知识找找类似，编编知识网，互相学习一下。

        下面以一个需求开始多线程“同步”的总结：

        “子线程循环10次，接着主线程循环100次，接着又回到子线程循环10次，接着再回到主线程循环100次，如此循环50次，请写出程序”。

         

         见到这个题目之后，我在想如果我不用多线程来实现，怎么解决呢？

         我想我会写三个for循环，像是这样：

for(int i=0;i< 50;i++)
{
	for(int j=0;j<10;j++)
	{
		System.out.println("子线程第"+ j +"次，"+"在第"+ i + "趟循环当中");
	}
	for(int k=0;k<100;k++)
	{
		System.out.println("主线程第"+ k +"次，"+"在第"+ i + "趟循环当中");
	}
}

        用一个单线程的for循环嵌套来输出和预期完全相同的结果。按照这个思路，将程序逐步向多线程的方向去做：

        Version 1:

public class TraditionalThreadCommunication {
	public static void main(String[] args) {
		new Thread(
				new Runnable(){
					@Override
					public void run(){
						for(int i=1;i<=50;i++){
							for(int j=1;j<=10;j++){
								System.out.println("sub thread sequece of" + j + "loop for" + i);
							}
						}
					}
				}
		).start();
		
		for(int i=1;i<=50;i++){
			for(int j=1;j<=10;j++){
				System.out.println("main thread sequece of" + j + "loop for" + i);
			}
		}
	}
}

        如上代码，引入了子线程和主线程，能够满足子线程一共跑了500次，主线程一共跑了5000次，但是线程在运行过程中是乱序的：

            

        之所以程序输出是乱序，是因为没有实现“互斥”，即没有加“synchronized()”约束，于是参考第二版代码：

       Version 2:

public class TraditionalThreadCommunication {
	public static void main(String[] args) {
		new Thread(
				new Runnable(){
					@Override
					public void run(){
						synchronized(TraditionalThreadSynchronized.class){
							for(int i=1;i<=50;i++){
								for(int j=1;j<=10;j++){
									System.out.println("sub thread sequece of" + j + "loop for" + i);
								}
							}
						}
					}
				}
		).start();
		
		for(int i=1;i<=50;i++){
			synchronized(TraditionalThreadSynchronized.class){
				for(int j=1;j<=10;j++){
					System.out.println("main thread sequece of" + j + "loop for" + i);
				}
			}
		}
	}
}

        此时代码的输出效果如图：

           

     

        此时实现了子线程、主线程每10个输出1组，但是没有实现交替显示，主线程全部执行完成之后，才执行子线程，如上图所示，那么要实现子、主线程交替显示，应该设计成第三版本的代码，如下：

        Version3:

public class TraditionalThreadCommunication {
	
	
	public static void main(String[] args) {
		final Business business = new Business();
		new Thread(
				new Runnable(){
					@Override
					public void run(){
						for(int i=1;i<=50;i++){
							business.sub(i);
						}
					}
				}
		).start();
		
		for(int i=1;i<=50;i++){
			business.main(i);
		}
	}
}
class Business{
	public synchronized void sub(int i){
		for(int j=1;j<=10;j++){
			System.out.println("sub thread sequece of" + j + "loop for" + i);
		}
	}
	
	public synchronized void main(int i){
		for(int j=1;j<=100;j++){
			System.out.println("main thread sequece of" + j + "loop for" + i);
		}
	}
	
}

        如上代码所示，将子线程和主线程中需要输出的方法封装到了一个Business类中，定义sub()和main()，分别循环10次和100次，通过synchronized关键字约束实现线程互斥，同步的调用则在main()方法中，子线程调用sub方法，主线程调用main方法，输出结果如图：

             

        还是没有实现，此时，第四个版本出现了：

  

       Version 4:

public class TraditionalThreadCommunication {
	
	
	public static void main(String[] args) {
		final Business business = new Business();
		new Thread(
				new Runnable(){
					@Override
					public void run(){
						for(int i=1;i<=50;i++){
							business.sub(i);
						}
					}
				}
		).start();
		
		for(int i=1;i<=50;i++){
			business.main(i);
		}
	}
}
class Business{
	private boolean bShouldSub = true;
	public synchronized void sub(int i){
		if(!bShouldSub)
		{
			try {
				this.wait();
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		}
		for(int j=1;j<=10;j++){
			System.out.println("sub thread sequece of" + j + "loop for" + i);
		}
		bShouldSub = true;
		this.notify();
	}
	
	public synchronized void main(int i){
		if(bShouldSub)
		{
			try {
				this.wait();
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		}
		for(int j=1;j<=100;j++){
			System.out.println("main thread sequece of" + j + "loop for" + i);
		}
		bShouldSub = false;
		this.notify();
	}
	
}

        如上代码，在Business类中，通过boolean值“bShouldSub”限制，用作主线程之后切换子线程，子线程之后切换主线程。以及"this.notify()"通知唤醒".wait()"状态的其他线程。据此，则实现了该题目，也了解了线程同步之间应该如何操作。

       That's all.