java多线程:生产者和消费者（两种方法） 不去继承Thread类或实现Runnable接口的写法

题目：现在两个线程，可以操作初始值为零的一个变量，实现一个线程对该变量加1，一个线程对该变量减1，实现交替，来10轮，变量初始值为零。
方法一：使用synchronized控制
先创建资源类

class Aircondition{
	private int number = 0;
	
	public synchronized void increment() throws Exception{
		//		1.判断
		if(number != 0) {
			this.wait();
		}
		//		2.干活
		number++;
		System.out.println(Thread.currentThread().getName()+"	"+number);
		//		3.通知
		this.notifyAll();
	}
	
	public synchronized void decrement() throws Exception{
//		1.判断
		if(number == 0) {
			this.wait();
		}
//		2.干活
		number--;
		System.out.println(Thread.currentThread().getName()+"	"+number);
//		3.通知(唤醒所有)一般不会影响多线程
		this.notifyAll();
	}
}

然后在主方法里面，创建线程的时候，使用Lambda 表达式。注意Lambda表达式一定是函数式接口才可以用lambda表达式 Lambda 表达式就是解决了匿名内部类语法冗余的现象。就是直接创建出来两个线程去操作对应的资源类的方法就可以了。

ublic static void main(String[] args) {
		// TODO Auto-generated method stub
		Aircondition aircondition = new Aircondition();
		new Thread( () ->{
			for (int i = 0; i < 4; i++) {
				try {
//					Thread.sleep(200);
					aircondition.increment();
				} catch (Exception e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
			}
		},"a").start();
		new Thread( () ->{
			for (int i = 0; i < 4; i++) {
				try {
//					Thread.sleep(300);
					aircondition.decrement();
				} catch (Exception e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
			}
		},"b").start();

从图中可以看出a和b分别打印了。

方法二：使用lock和condition实现。只需要在资源类里对线程抢占的部分换用不用的锁。

import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

class Aircondition{
	private int number = 0;
	Lock lock = new ReentrantLock();
	Condition condition = lock.newCondition();
	
	public void increment() throws Exception{
		
		lock.lock();
		try {
			//1.判断
			if(number != 0) {
				condition.await();
			}
			//2.干活
			number++;
			System.out.println(Thread.currentThread().getName()+"	"+number);
			//3.通知
			condition.signalAll();
		} catch (Exception e) {

		} finally {
			lock.unlock();
		}
	}
	
	public void decrement() throws Exception{
		lock.lock();
		try {
			//1.判断
			if(number == 0) {
				condition.await();
			}
			//2.干活
			number--;
			System.out.println(Thread.currentThread().getName()+"	"+number);
			//3.通知
			condition.signalAll();
		} catch (Exception e) {

		} finally {
			lock.unlock();
		}
	}
}

主方法里面的代码和synchronized的一样，我就不粘了。

进阶：
当有有四个线程操作资源类，会出现什么情况呢?

运行结果里面出现了2，那么为什么会出现这个2呢？我们在资源类写的逻辑是只能num==0就让操作减的那个线程等待，num!=0就让操作加的那个线程等待，逻辑是没有错的。那么是为什么出现2。

那这里就需要知道线程的“虚假唤醒”了。
防止线程的虚假唤醒，只要有wait需要用while判断(多线程的调度交换判断绝对不许用if，必须用while，苏醒后要重新判断一次)。while的本质是循环加判断。

那么出现‘2’这个情况的详细分析我手写了一下。

所以我们需要做的就是将上面代码部分的if（）改成while（）就可以了