18.线程的通信 - 《Java 基础》

线程的通信

线程的通信

例子：使用两个线程打印1~100。线程1，线程2 交替打印

使用到的方法：

wait（）：一旦执行此方法，当前线程就会进入阻塞状态，并释放同步监视器（锁）。
notify（）：一旦执行此方法，就会唤醒一个被wait的线程。如果有多个线程被wait（），就会唤醒优先级高的线程。
notifyAll（）：一旦执行此方法，就会唤醒所有被wait的线程。

/**
 * 线程通信的例子：使用两个线程打印1~100。线程1，线程2 交替打印
 */
class Number implements Runnable{
    private int number=1;
    @Override
    public void run() {
        while (true){
            synchronized (this){
                //此时会唤醒被wait阻塞的线程
                this.notify();
                if(number<=100){
                    System.out.println(Thread.currentThread().getName()+":"+number);
                    number++;
                    try {
                        //此时，会阻塞当前线程，并释放锁
                        this.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                else{
                    break;
                }
            }
        }
    }
}
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("线程1");
        t2.setName("线程2");
        t1.start();
        t2.start();
    }
}

18.线程的通信 - 图1

流程解析

当线程1进入同步方法块之后拿到了同步监视器（锁），因为此时为第1个线程没有需要它唤醒的被阻塞的线程，当执行完输出后，该线程1被wait()方法阻塞，同时释放了锁，则此时第2个线程就可以进入同步方法块，拿到了同步监视器（锁），执行了notify()方法，唤醒了之前被wait()所阻塞的线程1，但是由于此时是线程2拿到的锁（同步监视器），所以依旧是单线程，第2个线程执行完输出，到wait()后，也会被阻塞，同时释放锁，此时线程1就可以进来了，拿了锁之后，执行notify()方法，唤醒了线程2，依次执行下去，下一个线程拿到锁以后，唤醒上一个线程，然后输出结果后被阻塞，释放锁。就会出现交替输出

wait()与notify()和notifyAll()

wait():令当前线程挂起并放弃CPU、同步资源并等待，使别的线程可访问并修改共享资源，而当前线程排队等候其他线程调用notify()或notifyAll()方法唤醒，唤醒后等待重新获得对监视器的所有权后才能继续执行。
notify():唤醒正在排队等待同步资源的线程中优先级最高者结束等待
notifyAll ()：唤醒正在排队等待资源的所有线程结束等待.
这三个方法只有在synchronized方法或synchronized代码块中才能使用，否则会报java.lang.IllegalMonitorStateException异常。
因为这三个方法必须有锁对象调用，而任意对象都可以作为synchronized的同步锁，因此这三个方法只能在Object类中声明。

wait() 方法

在当前线程中调用方法：对象名.wait()
使当前线程进入等待（某对象）状态，直到另一线程对该对象发出 notify(或notifyAll) 为止。
调用方法的必要条件：当前线程必须具有对该对象的监控权（加锁）
调用此方法后，当前线程将释放对象监控权，然后进入等待
在当前线程被notify后，要重新获得监控权，然后从断点处继续代码的执行。

notify()/notifyAll()

在当前线程中调用方法：对象名.notify()
功能：唤醒等待该对象监控权的一个/所有线程。
调用方法的必要条件：当前线程必须具有对该对象的监控权（加锁）

sleep() 和 wait() 的异同

相同点：一旦执行方法，都可以使得当前线程进入阻塞状态。
不同点：
- 1、两个方法声明的位置不同：Thread类中声明sleep(),Object类中声明wait()
- 2、调用的要求不同：sleep()可以在任何场需要的场景下调用；wait()必须使用在同步代码块或者同步方法中
- 3、关于是否释放同步监视器：如果两个方法都在同步代码块或同步方法中，sleep()不会释放锁，wait()会释放锁

经典例题：：生产者/消费者问题

生产者(Productor)将产品交给店员(Clerk)，而消费者(Customer)从店员处
取走产品，店员一次只能持有固定数量的产品(比如:20），如果生产者试图
生产更多的产品，店员会叫生产者停一下，如果店中有空位放产品了再通
知生产者继续生产；如果店中没有产品了，店员会告诉消费者等一下，如
果店中有产品了再通知消费者来取走产品。

分析

1、是否是多线程问题？是，生产者线程，消费者线程

2、是否有共享数据？是，店员（或产品）

3、如何解决线程安全问题？同步机制，有三种方法

4、是否涉及线程通讯问题？是

/**
 * 生产者/消费者问题
 */
//店员
class Clerk{
    private int productNum=0;
    //生产
    public synchronized void addProduct() {
        if(productNum>20){
            try {
                //等待
                wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        else{
            productNum++;
            System.out.println(Thread.currentThread().getName()+"生产第"+productNum+"个产品");
            //唤醒消费者
            notify();
        }
    }
    //消费者
    public synchronized void customerProduct() {
        if(productNum<=0){
            try {
                //等待
                wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        else{
            System.out.println(Thread.currentThread().getName()+"消费第"+productNum+"个产品");
            productNum--;
            //唤醒生产者
            notify();
        }
    }
}
//生产者
class Productor extends Thread{
    Clerk clerk;
    public Productor(Clerk clerk) {
        this.clerk = clerk;
    }
    @Override
    public void run() {
        System.out.println("生产者，开始生产产品...");
        while(true){
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            clerk.addProduct();
        }
    }
}
//消费者
class  Customer extends Thread{
    Clerk clerk;
    public Customer(Clerk clerk) {
        this.clerk = clerk;
    }
    @Override
    public void run() {
        System.out.println("消费者，开始消费产品...");
        while (true) {
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            clerk.customerProduct();
        }
    }
}
public class ProductTest {
    public static void main(String[] args) {
        Clerk clerk=new Clerk();
        Productor p1=new Productor(clerk);
        Customer c1=new Customer(clerk);
        p1.setName("生产者");
        c1.setName("消费者");
        p1.start();
        c1.start();
    }
}