生产者消费者

package com.jxj.multiThreading.blibliLearning;

import java.util.Date;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class ProducerConsumerTraditional {
    public static void main(String[] args) {
        Data data=new Data();
        //ABCD四个线程，AC线程增加1，BD线程减1，各100轮
        new Thread(()->{
            for (int i=0;i<100;i++){
                try {
                    data.increase();
                    Thread.yield();//模拟线程的切换
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        },"A").start();
        new Thread(()->{
            for (int i=0;i<100;i++){
                try {
                    data.increase();
                    Thread.yield();
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        },"C").start();
        new Thread(()->{
            for (int i=0;i<100;i++){
                try {
                    data.decrease();
                    Thread.yield();
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        },"B").start();
        new Thread(()->{
            for (int i=0;i<100;i++){
                try {
                    data.decrease();
                    Thread.yield();
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        },"D").start();


        DataNewWay dataNewWay=new DataNewWay();
        //ABCD四个线程，AC线程增加1，BD线程减1，各10轮
        new Thread(()->{
            for (int i=0;i<10;i++){
                try {
                    dataNewWay.increase();
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        },"AA").start();
        new Thread(()->{
            for (int i=0;i<10;i++){
                try {
                    dataNewWay.decrease();
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        },"BB").start();
        new Thread(()->{
            for (int i=0;i<10;i++){
                try {
                    dataNewWay.increase();
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        },"CC").start();
        new Thread(()->{
            for (int i=0;i<10;i++){
                try {
                    dataNewWay.decrease();
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        },"DD").start();
    }
}

//资源类
class  Data{
    private  int num=0;
    //因为加锁所以只有一个线程能进该方法
    public synchronized void increase()throws Exception{
        //虽然只有一个线程能进，但是如果wait，将释放锁，另一个线程有可能抢到锁并执行increase，同理另一个线程也将wait并释放锁，这个时候就有两个释放锁的线程在等待
        while(num>=100) {
            wait();//wait会释放锁，唤醒后如果再次抢到锁，会从释放锁的执行的代码后开始执行，意味着再次抢到锁后将不执行wait(),所以如果开两个或以上线程去increase的话，必须使用while循环去判断，防止虚假唤醒
        };
        num++;
        System.out.println(Thread.currentThread().getName()+":"+num);
        //notifyAll会唤醒所有的，所有等待线程都会被唤醒，但是只有一个能抢到锁资源,而notify只会唤醒一个随机的一个
        //notify();//如果increase或decrease开两个或以上的线程，用notify会死锁,有点类似ABA的问题
        notifyAll();
    }
    public synchronized void decrease()throws Exception{
        while (num==0){ wait(); }num--;
        System.out.println(Thread.currentThread().getName()+":"+num);
        notifyAll();
    }
}

//资源类新方式
class  DataNewWay{
    private  int num=0;
    Lock lock=new ReentrantLock();
    Condition condition=lock.newCondition();

    public  void increase()throws Exception{
        lock.lock();
        try {
            while(num>0) {
                condition.await();  //=wait();
            };
            num++;
            System.out.println(Thread.currentThread().getName()+":"+num);
            condition.signalAll();//=notifyAll();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }


    }
    public  void decrease()throws Exception{
        lock.lock();
        try {
            while (num==0){ condition.await(); }num--;
            System.out.println(Thread.currentThread().getName()+":"+num);
            condition.signalAll();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }
}