Java multi-thread

第一个例子

一个非常简单的往仓库存取苹果的例子（设定为只存取一个）：

• 只有仓库为空时才能放，只有不为空时才能取（不能一直取或一直放）。要实现这个，可以使用等待和唤醒机制。当a放了之后，先唤醒取苹果的线程b，然后sleep；b取了苹果后，先唤醒a，然后sleep，这样重复就实现了两个线程的通信，不会出现已经空了还取（或者放苹果了还放）的现象

class Input implements Runnable{//生产者
	private Res r;
	Input(Res r){
		this.r = r;
	}
	public void run(){
		while(true){
			synchronized(r){
				if(r.flag == true)
					try{r.wait();}catch(Exception e){}
				r.apple = 1;//存
				System.out.println("apple = " + r.apple);
				r.flag = true;
				r.notify();
			}
		}
	}
}

class Output implements Runnable{//消费者
	private Res r;
	Output(Res r){
		this.r = r;
	}
	public void run(){
		while(true){
			synchronized(r){
				if(r.flag == false)
					try{r.wait();}catch(Exception e){}
				r.apple = 0;//取
				System.out.println("apple = " + r.apple);
				r.flag = false;
				r.notify();
			}
		}
	}
}

class Res{
	int apple;
	boolean flag = false;//用于判断仓库是否为空，初始化为空
}

public class Test{
	public static void main(String[] args) {
		Res r = new Res();
        new Thread(new Input(r)).start();
        new Thread(new Output(r)).start();	

        //Input in = new Input(r);
		//Output out = new Output(r);

		//Thread t1 = new Thread(in);
		//Thread t2 = new Thread(out);

		//t1.start();
		//t2.start();
	}
}

关于wait、notify和notifyAll

• wait：在其他线程调用此对象的 notify() 方法或 notifyAll() 方法前，导致当前线程等待（等待线程在线程池中 ）。当线程执行了 wait方法时，它不再持有锁
• notify：唤醒在此对象监视器（锁）上等待的单个线程
• notifyAll：唤醒在此对象监视器上等待的所有线程
• 调用方法：格式： 对象/锁.wait()

• wait、notify、notifyAll 为什么必须使用在同步内部？
• 因为它们要对持有监视器（锁）的线程操作，而只有在进入同步代码块，才能拿到锁
• 为什么这些方法要定义在object类中？
• 因为它们必须由一个锁来调用，而锁可以是任意对象，可以被任意对象调用的方法定义在Object类中
• 注意：只有同一个锁上的被等待线程，可以被同一个锁上的线程notify唤醒

第二个例子（第一个例子的升级版）

• 现在有2个生产者和2个消费者，其他条件同上（即仓库里只能有一个苹果，第一个生产者生产后，就不能再生产了）
• 如果在前面程序基础上，直接再创建一个生产者和一个消费者，则会出现问题：
• 设生产者为a1，a2，消费者为b1，b2。考虑这种情况：
• a1最先生产1个，然后躺了（执行了wait），a2接着进来了，看见已经有了1个，然后也躺了。接着b1进来了，消费了1个，然后唤醒了a1然后躺（这时a1具备了执行资格，但假设还没有执行），接着b2进来，看见没有了，于是躺。 现在，除了a1全躺了，a1生产了1个然后唤醒了a2（因为a2最先躺，就算是随机唤醒我们也假设唤醒a2），这时注意了：a2接着wait这行代码执行，结果就又生产了1个，产生了错误。

• 这里体现了2个问题：
• 1. 生产后，应该唤醒消费者才对
• 2. 无论谁被唤醒后，都应该再次判断flag
• 解决方案（代码如下，还有一些细微改动）：
• 1. 直接上notifyAll，只用notify，容易出现没有唤醒对方线程的情况，导致所有线程全躺了
• 2. 变if判断为while判断，避免只判断一次，防止虚假唤醒

class Input implements Runnable{
	private Res r;
	Input(Res r){
		this.r = r;
	}
	public void run(){
		while(true){
			synchronized(r){
				while(r.flag == true)//循环判断，避免唤醒后不判断
					try{r.wait();}catch(Exception e){}
				r.apple++;//需要改为++，如果还是=1，那么一旦出现了问题，我们就看不到苹果数量的变动
				System.out.println(Thread.currentThread().getName() + " Input apple = " + r.apple);
				r.flag = true;
				r.notifyAll();//全部唤醒
			}
		}
	}
}

class Output implements Runnable{
	private Res r;
	Output(Res r){
		this.r = r;
	}
	public void run(){
		while(true){
			synchronized(r){
				while(r.flag == false)
					try{r.wait();}catch(Exception e){}
				r.apple--;//解释同上
				System.out.println(Thread.currentThread().getName() + "   Output apple = " + r.apple);//这里空格数不同，易于观察
				r.flag = false;
				r.notifyAll();
			}
		}
	}
}

class Res{
	int apple;
	boolean flag = false;//用于判断仓库是否为空，初始化为空
}

public class Test{
	public static void main(String[] args) {
		Res r = new Res();
        new Thread(new Input(r)).start();
        new Thread(new Input(r)).start();
        new Thread(new Output(r)).start();		
        new Thread(new Output(r)).start();	
        
	}
}

继续优化

• jdk1.5中（或称5.0）提供了多线程升级解决方案。将Synchronized替换成显式的Lock操作；将Object中的wait、notify、notifyAll替换为Condition对象，该对象可以通过Lock对象中的方法newCondition进行获取
• 第二个例子存在的问题是：使用了notifyAll唤醒了所有对象，但这是不必要的。在下面的程序中，实现了本方只唤醒对方

import java.util.concurrent.locks.*;

class Input implements Runnable{
	private Res r;
	Input(Res r){
		this.r = r;
	}
	public void run()
	{                      
		while(true){
			r.lo.lock();
			try{
				while(r.flag)
					r.condition_pro.await();//使生产者冻结在condition_pro
				r.apple++;
				System.out.println(Thread.currentThread().getName() + " Input apple = " + r.apple);
				r.flag = true;
				r.condition_con.signal();//唤醒condition_con上的线程，即消费者
			}
			catch(Exception e){}
			finally{
				r.lo.unlock();//unlock操作必须执行，因为可能出现获取lock后冻结的情况
			}
		}
	}
}

class Output implements Runnable{
	private Res r;
	Output(Res r){
		this.r = r;
	}
	public void run(){
		while(true){
			r.lo.lock();
			try{
				while(!r.flag)
					r.condition_con.await();//使消费者冻结在condition_con
				r.apple--;
				System.out.println(Thread.currentThread().getName() + "   Output apple = " + r.apple);
				r.flag = false;
				r.condition_pro.signal();
			}
			catch(Exception e){}
			finally{
				r.lo.unlock();
			}
		}
	}
}

class Res{
	int apple;
	boolean flag = false;

	Lock lo = new ReentrantLock();//类 ReentrantLock 实现了Lock接口
	Condition condition_pro = lo.newCondition();//
	Condition condition_con = lo.newCondition();
}

public class Test{
	public static void main(String[] args) {
		Res r = new Res();


        new Thread(new Input(r)).start();
        new Thread(new Input(r)).start();
        new Thread(new Output(r)).start();		
        new Thread(new Output(r)).start();	
        
	}
}

解释

• Lock 实现提供了比使用 synchronized 方法和语句可获得的更广泛的锁定操作。此实现允许更灵活的结构，可以具有差别很大的属性，可以支持多个相关的 Condition 对象。
• Condition 将 Object 监视器方法（wait、notify 和 notifyAll）分解成截然不同的对象。
• 也就是说可以为生产者和消费者们各自创建一个condition，这样可以让生产者等待在这个condition_pro，消费者等待在另一个condition_con，唤醒的时候就可以只唤醒对方condition中的线程
• 实际上每个Condition对象都包含着一个队列，该队列是Condition对象实现等待/通知功能的关键，深入剖析可以参考这篇：Java多线程Condition接口原理详解_路漫漫，水迢迢-CSDN博客_condition接口

，