线程系列3--Java线程同步通信技术

       上一篇文章我们讲解了线程间的互斥技术，使用关键字synchronize来实现线程间的互斥技术。根据不同的业务情况，我们可以选择某一种互斥的方法来实现线程间的互斥调用。例如：自定义对象实现互斥（synchronize("自定义对象"){}），同一个类实例对象（synchronize(this){}）,类的字节码对象（synchronize(字节码对象){}）。这三种方法均可实现线程间的互斥，我们实际运用中灵活使用。

下面进入今天的正题：线程--线程间的同步通信技术；我们还是以传智播客中的代码为例来讲解，子线程运行10次，主线程运行10次，如此交替运行50次。

首先看不适用同步技术时的问题代码：

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("子线程:"+Thread.currentThread().getName()+"运行第"+i+"次，重复第"+j+"次");
				}
			}
		}
	}).start();
		
	for(int i=1;i<=50;i++){
		for(int j=1;j<=10;j++){
			System.out.println("主线程:"+Thread.currentThread().getName()+"运行第"+i+"次，重复第"+j+"次");
		}
	}
}

上面代码的运行结果可知，子线程与主线程间是杂乱无章的运行，显然不能满足我的要求。那我们来稍作调整。代码如下：

public class ThreadSynchronizedTechnology {

	public static void main(String[] args) {
		new Thread(new Runnable() {
			@Override
			public void run() {
				for(int i=1;i<=50;i++){
　　　　　　　　　　　　　　　　　　　　　　　//使用类的字节码作为互斥对象
					synchronized(ThreadSynchronizedTechnology.class){
						for(int j=1;j<=10;j++){
							System.out.println("子线程:"+Thread.currentThread().getName()+"运行第"+i+"次，重复第"+j+"次");
						}
					}
				}
			}
		}).start();
		
		for(int i=1;i<=50;i++){
			synchronized(ThreadSynchronizedTechnology.class){
				for(int j=1;j<=10;j++){
					System.out.println("主线程:"+Thread.currentThread().getName()+"运行第"+i+"次，重复第"+j+"次");
				}
			}
		}
	}
	
}

上面的代码我们使用类的字节码作为互斥对象，显然程序不再是杂乱无章的运行，子线程与主线程都能完整的运行完，但是没有实现我们要求的交替运行，不要急我接着调整，我非常喜欢张孝祥老师循序渐进的讲课方式（我不是托，是发自内心的），下面我们接着调整：

public class ThreadSynchronizedTechnology {
	public static void main(String[] args) {
		final Songzl song = new Songzl();
		new Thread(new Runnable() {
			@Override
			public void run() {
				for(int i=1;i<=50;i++){
					song.sub(i);
				}
			}
		}).start();
		
		for(int i=1;i<=50;i++){
			song.main(i);
		}
	}
}
class Songzl{
	//子线程运行的方法
	public void sub(int i){
		synchronized(Songzl.class){
			for(int j=1;j<=10;j++){
				System.out.println("子线程:"+Thread.currentThread().getName()+"运行第"+i+"次，重复第"+j+"次");
			}
		}
	}
	//主线程运行的方法
	public void main(int i){
		synchronized(Songzl.class){
			for(int j=1;j<=10;j++){
				System.out.println("主线程:"+Thread.currentThread().getName()+"运行第"+i+"次，重复第"+j+"次");
			}
		}
	}
}

打印结果依然不是交替运行，我调成这样是为了体现编程的面向对象思想，将相关联的方法封装到同一个类中，方便代码运维。我们接着调整代码：

public class ThreadSynchronizedTechnology {
	public static void main(String[] args) {
		final Songzl song = new Songzl();
		new Thread(new Runnable() {
			@Override
			public void run() {
				for(int i=1;i<=50;i++){
					song.sub(i);
				}
			}
		}).start();
		
		for(int i=1;i<=50;i++){
			song.main(i);
		}
	}
}
class Songzl{
	//实现线程同步通信，互斥的方法共享次变量
	private boolean jiaoti = true;
	//子线程运行的方法:同一个类中方法互斥，类似与synchronized(this){}
	public synchronized void sub(int i) {
		if(!jiaoti){
			try {
				this.wait();
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
		for(int j=1;j<=10;j++){
			System.out.println("子线程:"+Thread.currentThread().getName()+"运行第"+i+"次，重复第"+j+"次");
		}
		jiaoti = false;
		this.notify();
	}
	//主线程运行的方法:同一个类中方法互斥，类似与synchronized(this){}
	public synchronized void main(int i){
		if(jiaoti){
			try {
				this.wait();
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
		for(int j=1;j<=10;j++){
			System.out.println("主线程:"+Thread.currentThread().getName()+"运行第"+i+"次，重复第"+j+"次");
		}
		jiaoti = true;
		this.notify();
	}
}

打印结果可见，已经实现子线程和主线程有条不紊的交替运行，线程间既能互斥，同时又可以相互同步通信运行；线程的互斥是通过synchronized实现的，线程间的同步通信是两个线程间共同持有一个变量来实现的。但是线程有一个“假唤醒”的情况，虽然发生率低，但是我们不能忽略，继续调整代码：

public class ThreadSynchronizedTechnology {
	public static void main(String[] args) {
		final Songzl song = new Songzl();
		new Thread(new Runnable() {
			@Override
			public void run() {
				for(int i=1;i<=50;i++){
					song.sub(i);
				}
			}
		}).start();
		
		for(int i=1;i<=50;i++){
			song.main(i);
		}
	}
}
class Songzl{
	//实现线程同步通信，互斥的方法共享次变量
	private boolean jiaoti = true;
	//子线程运行的方法:同一个类中方法互斥，类似与synchronized(this){}
	public synchronized void sub(int i) {
		//避免线程的假唤醒
		while(!jiaoti){
			try {
				this.wait();
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
		for(int j=1;j<=10;j++){
			System.out.println("子线程:"+Thread.currentThread().getName()+"运行第"+i+"次，重复第"+j+"次");
		}
		jiaoti = false;
		this.notify();
	}
	//主线程运行的方法:同一个类中方法互斥，类似与synchronized(this){}
	public synchronized void main(int i){
		//避免线程的假唤醒
		while(jiaoti){
			try {
				this.wait();
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
		for(int j=1;j<=10;j++){
			System.out.println("主线程:"+Thread.currentThread().getName()+"运行第"+i+"次，重复第"+j+"次");
		}
		jiaoti = true;
		this.notify();
	}
}

我们使用while循环来避免这种假唤醒的情况，当CPU任性的给与不该执行的线程、或者线程神经病的自己唤醒自己，我们可以使用while循环来避免上述情况。好了到此为止，代码已经完全满足我们的需求了。通过上面代码的循序渐进，我们很容易理解线程间的同步与互斥技术。

总结：线程之间的制约关系？

       当线程并发执行时，由于资源共享和线程协作，使用线程之间会存在以下两种制约关系。

     （1）间接相互制约。一个系统中的多个线程必然要共享某种系统资源，如共享CPU，共享I/O设备，所谓间接相互制约即源于这种资源共享，打印机就是最好的例子，线程A在使用打印机时，其它线程都要等待。

     （2）直接相互制约。这种制约主要是因为线程之间的合作，如有线程A将计算结果提供给线程B作进一步处理，那么线程B在线程A将数据送达之前都将处于阻塞状态。

       间接相互制约可以称为互斥，直接相互制约可以称为同步，对于互斥可以这样理解，线程A和线程B互斥访问某个资源则它们之间就会产个顺序问题——要么线程A等待线程B操作完毕，要么线程B等待线程操作完毕，这其实就是线程的同步了。因此同步包括互斥，互斥其实是一种特殊的同步。