详解线程的通信

1.引例：使用两个线程打印1-100.线程1，线程2交替打印。
（1）涉及到到三个方法：
1⃣️notifyall()：唤起多个被wait()的线程。
2⃣️notify()：唤起被wait()的一个优先级高的线程。
3⃣️wait()：一旦执行此方法，当前线程就进入阻塞状态，并释放同步监视器。

public class CommunicationTest {
    public static void main(String[] args){
        Number number=new Number();

        Thread t1=new Thread(number);
        Thread t2=new Thread(number);

        t1.setName("线程一");
        t2.setName("线程二");

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

class Number implements Runnable{

    private int number=1;
    @Override
    public void run() {
        while (true){

            synchronized (this){
                //notifyall()唤起多个线程
                //notify()唤起一个线程

                notify();
                if(number<=100){
                    System.out.println(Thread.currentThread().getName()+":"+number);
                    number++;

                    //使得调用如下wait()方法的线程进入阻塞状态
                    try {
                        wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }else {
                    break;
                }
            }

        }
    }
}

（2）注意：
1⃣️上述三个方法只能出现在同步代码块或同步方法中。
2⃣️上述三个方法的调用者必须是同步代码块或同步方法中的同步监视器，否则会出现异常。
（3）详解sleep()和wait()的异同
2.经典例题：生产者/消费者问题。
（1）生产者(Productor)将产品交给店员(Clerk)，而消费者(Customer)从店员处取走产品，店员一次只能持有固定数量的产品(比如：20)，如果生产者试图生成更多的产品，店员会叫生产者停一下，如果店中有空位放产品了再通知生产者继续生产：如果店中没有产品了，店员会告诉消费者等一下，如果店中有了产品再通知消费者来取走产品。
（2）这里可能会出现两个问题：
1⃣️生产者比消费者快时，消费者就会漏掉一些数据没有取到。
2⃣️消费者比生产者快时，消费者会取相同的数据。
（3）分析
1⃣️是否为多线程问题？是，生产者线程，消费者线程
2⃣️是否有线程安全问？是，店员（或产品）
3⃣️如何解决线程的安全问题？同步机制，有三种方法。
4⃣️是否涉及到线程通信？是

public class ProductTest {
    public static void main(String[] args){
        Clerk clerk=new Clerk();
        Produtor p1=new Produtor(clerk);
        p1.setName("生产者一");

        Consumer c1=new Consumer(clerk);
        c1.setName("消费者一");

        p1.start();
        c1.start();

    }

}

class Clerk{

    private int productCount=0;

    //生产产品
    public synchronized void produceProductor() {
        if (productCount<20){
            productCount++;
            System.out.println(Thread.currentThread().getName()+":开始生产第"+productCount+"个产品");

            notify();
        }else {
            try {
                wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
    //消费产品
    public synchronized void consumeProduct() {
        if (productCount>0){
            System.out.println(Thread.currentThread().getName()+":开始消费第"+productCount+"个产品");
            productCount--;

            notify();
        }else {
            try {
                wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

//生产者
class Produtor extends Thread{
    private Clerk clerk;

    public Produtor(Clerk clerk){
        this.clerk=clerk;
    }

    @Override
    public void run() {
        System.out.println(getName()+":开始生产产品");


        while (true){
            clerk.produceProductor();
        }
    }
}


//消费者
class Consumer extends Thread{
    private Clerk clerk;
    public Consumer(Clerk clerk){
        this.clerk=clerk;
    }

    @Override
    public void run() {
        System.out.println(getName()+":开始消费产品");

        while (true){
            clerk.consumeProduct();
        }
    }
}