传统版生产者消费者模式2.0

,lock,condition,signalAll

package Juc;

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

/**
 * 
 * 高并发：低耦合高内聚，线程操纵资源类
 * 判断，干活，唤醒通知
 * 严防多线程并发状态下的虚假唤醒使用while()
 * 8
 * 题目：一个初始值为0，俩个线程对其交替操作，一个加一一个减一，5轮
 * 1 线程       操作    资源类
 */

class ShareData{
	private int number = 0;
	private Lock lock = new ReentrantLock();
	private Condition condition = lock.newCondition();
	
	public void increment()throws Exception{
		lock.lock();
		try {
			//1.判断
			while(number!=0){  //if()判断会出现虚假唤醒
				//等待，不能生产
				condition.await();
			}
			//2.干活
			number++;
			System.out.println(Thread.currentThread().getName()+"\t"+number);
			//3.通知唤醒
			condition.signalAll();
		} finally {
			lock.unlock();
		}
		
	}
	
	
	public void decrement()throws Exception{
		lock.lock();
		try {
			//1.判断
			while(number==0){
				//等待，不能生产
				condition.await();
			}
			//2.干活
			number--;
			System.out.println(Thread.currentThread().getName()+"\t"+number);
			//3.通知唤醒
			condition.signalAll();
		} finally {
			lock.unlock();
		}
		
	}
}

public class Prodconsumer_TraditionDemo {

	public static void main(String[] args) {
		ShareData shareData = new ShareData();
		for (int i = 1; i <= 5; i++) {
			new Thread(() -> {
				try {
					shareData.increment();
				} catch (Exception e) {
					e.printStackTrace();
				}
			},"AA").start();
		}
		
		for (int i = 1; i <= 5; i++) {
			new Thread(() -> {
				try {
					shareData.decrement();
				} catch (Exception e) {
					e.printStackTrace();
				}
			},"BB").start();
		}
		
		for (int i = 1; i <= 5; i++) {
			new Thread(() -> {
				try {
					shareData.increment();
				} catch (Exception e) {
					e.printStackTrace();
				}
			},"CC").start();
		}
		
		for (int i = 1; i <= 5; i++) {
			new Thread(() -> {
				try {
					shareData.decrement();
				} catch (Exception e) {
					e.printStackTrace();
				}
			},"DD").start();
		}

	}
	/*
	题目：synchronized和Lock有什么区别？用新的lock有什么好处？
	1.原始构成
	   Synchronized是关键字属于JVM层面，
	   monitorenter(底层是通过monitor对象来完成，其实wait/notify等方法也依赖monitor对象只有在同步块或方法中才能调wait/notify等方法)
	   monitorexit
	   Lock 是具体类(java.util.concurrent.locks.lock)是api层面的锁
	2.使用方法
	   Synchronized 不需要用户手动释放锁，当synchronized代码执行完成后系统会自动让线程释放对锁的占用
	   Reentrantlock则需要用户去手动释放锁若没有主动释放锁，就有可能导致出现死锁的现象。
	       需要lock()和unlock()方法配合try/finally语句块来完成。
	3.等待是否可中断
	   synchronized不可中断，除非抛出异常或者正常运行完成。
	   Reentrantlock 可中断，1.设置超时方法。tryLock(Long timeout,TimeUnit unit)
	   						2.lockInterruptibly()放代码块中，调用interruptibly()方法可中断。
	4.假锁是否公平
	  synchronized非公平锁
	  Reentrantlock俩者都可以，默认非公平锁，构造方法可以传入boolean值，true为公平锁，false为非公平锁。
	  
	5.锁绑定多个条件Condition
	  synchronized没有
	  Reentrantlock用来实现分组唤醒需要唤醒的线程们，可以精确唤醒，不像synchronized随机唤醒或者唤醒全部线程。
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	*/
	
	
	
	

}