Synchronized

/*
* 线程之间的通信问题：生产者和消费者问题  等待唤醒，通知唤醒
* 线程交替执行 A B 操作同一个变量 num=0
* A num+1
* B num-1
* */

public class producter_comsumer {
    public static void main(String[] args) {
        A a =new A();
        new Thread(()->{
            for (int i = 0; i <10 ; i++) {
                try {
                    a.increment();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            };},"A").start();new Thread(()->{
            for (int i = 0; i <10 ; i++) {
                try {
                    a.increment();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            };},"C").start();

        new Thread(()->{
            for (int i = 0; i <10 ; i++) {
                try {
                    a.decrement();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            };},"B").start();

        new Thread(()->{
            for (int i = 0; i <10 ; i++) {
                try {
                    a.decrement();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            };},"D").start();
    }

}

//判断等待，业务，通知
class A{
    private int number=0;

    //+1
    public synchronized void increment() throws InterruptedException {
        while (number!=0){
            //等待
            this.wait();
        }
        number++;
        //通知其他线程，我+1完了
        System.out.println(Thread.currentThread().getName()+"=>"+number);
        this.notifyAll();
    }

    //-1
    public synchronized void decrement() throws InterruptedException {
        while (number==0){
            //等待
            this.wait();
        }
        number--;
        //通知其他线程，我-1完了
        System.out.println(Thread.currentThread().getName()+"=>"+number);
        this.notifyAll();
    }
}

• 注意要把判断换成while，如果用if就只判断一次就可能会造成虚假唤醒

Lock

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

public class producter_comsumer2 {
    public static void main(String[] args) {
        B a =new B();
        new Thread(()->{
            for (int i = 0; i <10 ; i++) {
                try {
                    a.increment();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            };},"A").start();new Thread(()->{
            for (int i = 0; i <10 ; i++) {
                try {
                    a.increment();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            };},"C").start();

        new Thread(()->{
            for (int i = 0; i <10 ; i++) {
                try {
                    a.decrement();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            };},"B").start();

        new Thread(()->{
            for (int i = 0; i <10 ; i++) {
                try {
                    a.decrement();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            };},"D").start();
    }

}

//判断等待，业务，通知
class B{
    private int number=0;

    Lock lock= new ReentrantLock();
    Condition condition = lock.newCondition();
    //    condition.await();//等待
    //   condition.signal();//唤醒

    //+1
    public  void increment() throws InterruptedException {
        lock.lock();
        try {
            while (number!=0){
                //等待
                condition.await();
            }
            number++;
            System.out.println(Thread.currentThread().getName()+"=>"+number);
            //通知其他线程，我+1完了
            condition.signalAll();
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }

    //-1
    public  void decrement() throws InterruptedException {
        lock.lock();
        try {
            while (number==0){
                //等待
                condition.await();
            }
            number--;
            System.out.println(Thread.currentThread().getName()+"=>"+number);
            //通知其他线程，我-1完了
            condition.signalAll();
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }

    }
}

Condition

精准的通知和唤醒线程

package top.ltyzqhh.Lock;

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

public class C {
    public static void main(String[] args) {
        Data3 data = new Data3();

        new Thread(()->{ for (int i = 0; i <10 ; i++) data.printA();},"A").start();
        new Thread(()->{ for (int i = 0; i <10 ; i++) data.printB();},"B").start();
        new Thread(()->{ for (int i = 0; i <10 ; i++) data.printC();},"C").start();

    }
}

class Data3{
    private Lock lock= new ReentrantLock();
    private Condition condition1 =lock.newCondition();
    private Condition condition2 =lock.newCondition();
    private Condition condition3 =lock.newCondition();
    private int number =1; //1A 2B 3C

    public  void printA(){
        lock.lock();
        try {
            while (number!=1){
                //等待
                condition1.await();
            }
            number=2;
            System.out.println(Thread.currentThread().getName()+"=>AAAAA");
            //唤醒，唤醒指定的人，B
            condition2.signal();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }

    }
    public  void printB(){
        lock.lock();
        try {
            while (number!=2){
                //等待
                condition2.await();
            }
            number=3;
            System.out.println(Thread.currentThread().getName()+"=>BBBBB");
            //唤醒，唤醒指定的人，B
            condition3.signal();

        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }

    }
    public  void printC(){
        lock.lock();
        try {
            while (number!=3){
                //等待
                condition3.await();
            }
            number=1;
            System.out.println(Thread.currentThread().getName()+"=>CCCCC");
            //唤醒，唤醒指定的人，A
            condition1.signal();

        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }

    }

}