Java 线程通信

线程的通信

线程间同通信

为什么需要处理线程间通信?

当我们需要多个线程来共同完成一件任务，并且我们希望他们有规律的执行，那么多线程之间需要一些通信机制，可以协调它们的工作，以此实现多线程共同操作一份数据。

比如：线程A用来生产包子的，线程B用来吃包子的，包子可以理解为同一资源，线程A与线程B处理的动作，一个是生产，一个是消费，此时B线程必须等到A线程完成后才能执行，那么线程A与线程B之间就需要线程通信，即—— 等待唤醒机制。

案例：使用两个线程打印1-100,两个线程交替打印

涉及到三个方法的使用

• wait() 线程一旦执行此方法， 就进入到等待状态，同时会释放对同步监视器的调用
• notify()线程一旦执行此方法，就会唤醒被wait()的线程中优先级最高的哪一个线程，如果被wait的多个线程的优先级相同，则随机被唤醒一个。被唤醒的线程从被wait的位置开始继续执行
• notifyAll() 一旦执行此方法，就会唤醒所有被wait()的线程

注意点:

• 此三个方法的使用，必须是再同步代码块或同步方法中（Lock需要配合Condition实现线程间的通信）
• 此三个方法的调用者，必须是同步监视器。(方法中省略了thisthis.wait(),)否则会报异常。若synchronized(obj)则方法也需要用obj进行调用，obj.wait()、obj.notify()、obj.notifyAll()
• 此三个方法声明在object类中。

public class PrintNum  implements Runnable {
    private int number = 1;

    @Override
    public void run() {
        while (true) {
            synchronized (this) {
                notify();

                if (number <= 100) {
                    System.out.println(Thread.currentThread().getName() + "打印:" + number);
                    number++;
                    try {
                        wait(); //线程一旦执行此方法，就进入等待状态，同时会释放对同步监视器的调用
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                } else {
                    break;
                }
            }
        }
    }
}
    class NumberTest {
        public static void main(String[] args) {
            PrintNum p = new PrintNum();
            new Thread(p, "线程1").start();
            new Thread(p, "线程2").start();
        }
    }
//输出结果
线程1打印:1
线程2打印:2
线程1打印:3
线程2打印:4
线程1打印:5
线程2打印:6
线程1打印:7
线程2打印:8
线程1打印:9
线程2打印:10
线程1打印:11
线程2打印:12
线程1打印:13
线程2打印:14
线程1打印:15
线程2打印:16
线程1打印:17
线程2打印:18
线程1打印:19
线程2打印:20
线程1打印:21
线程2打印:22
线程1打印:23
线程2打印:24
线程1打印:25
线程2打印:26
线程1打印:27
线程2打印:28
线程1打印:29
线程2打印:30
线程1打印:31
线程2打印:32
线程1打印:33
线程2打印:34
线程1打印:35
线程2打印:36
线程1打印:37
线程2打印:38
线程1打印:39
线程2打印:40
线程1打印:41
线程2打印:42
线程1打印:43
线程2打印:44
线程1打印:45
线程2打印:46
线程1打印:47
线程2打印:48
线程1打印:49
线程2打印:50
线程1打印:51
线程2打印:52
线程1打印:53
线程2打印:54
线程1打印:55
线程2打印:56
线程1打印:57
线程2打印:58
线程1打印:59
线程2打印:60
线程1打印:61
线程2打印:62
线程1打印:63
线程2打印:64
线程1打印:65
线程2打印:66
线程1打印:67
线程2打印:68
线程1打印:69
线程2打印:70
线程1打印:71
线程2打印:72
线程1打印:73
线程2打印:74
线程1打印:75
线程2打印:76
线程1打印:77
线程2打印:78
线程1打印:79
线程2打印:80
线程1打印:81
线程2打印:82
线程1打印:83
线程2打印:84
线程1打印:85
线程2打印:86
线程1打印:87
线程2打印:88
线程1打印:89
线程2打印:90
线程1打印:91
线程2打印:92
线程1打印:93
线程2打印:94
线程1打印:95
线程2打印:96
线程1打印:97
线程2打印:98
线程1打印:99
线程2打印:100

进程已结束，退出代码为 0

wait()和sleep()的区别

• 相同点：一旦执行，当前线程都会进入到阻塞状态
• 不同点:
• 声明位置不同: wait()声明在object类中 sleep()声明在Thread类中
• 使用场景不同: wait()只能使用在同步代码块或同步方法中 sleep()可以使用在任何地方
• 实际功能不同:wait()一旦执行，会释放同步监视器 sleep()一旦执行，不会释放同步监视器
• 结束阻塞的方法不同: wait() 到达指定时间自动结束或被notify()唤醒，结束阻塞 sleep()到达指定时间后自动结束阻塞。

经典使用场景

案例：

生产者&消费者

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

public class ConsumerProducerTest {
    public static void main(String[] args) {
        Clerk clerk = new Clerk();
        Producer p1 = new Producer(clerk);

        Consumer c1 = new Consumer(clerk);
        Consumer c2 = new Consumer(clerk);

        p1.setName("生产者1");
        c1.setName("消费者1");
        c2.setName("消费者2");

        p1.start();
        c1.start();
        c2.start();
    }
}

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

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

    @Override
    public void run() {

        System.out.println("=========生产者开始生产产品========");
        while(true){

            try {
                Thread.sleep(40);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

            //要求clerk去增加产品
            clerk.addProduct();
        }
    }
}

//消费者
class Consumer extends Thread{
    private Clerk clerk;

    public Consumer(Clerk clerk){
        this.clerk = clerk;
    }
    @Override
    public void run() {
        System.out.println("=========消费者开始消费产品========");
        while(true){

            try {
                Thread.sleep(90);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

            //要求clerk去减少产品
            clerk.minusProduct();
        }
    }
}

//资源类
class Clerk {
    private int productNum = 0;//产品数量
    private static final int MAX_PRODUCT = 20;
    private static final int MIN_PRODUCT = 1;

    //增加产品
    public synchronized void addProduct() {
        if(productNum < MAX_PRODUCT){
            productNum++;
            System.out.println(Thread.currentThread().getName() +
                    "生产了第" + productNum + "个产品");
            //唤醒消费者
            this.notifyAll();
        }else{

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

    //减少产品
    public synchronized void minusProduct() {
        if(productNum >= MIN_PRODUCT){
            System.out.println(Thread.currentThread().getName() +
                    "消费了第" + productNum + "个产品");
            productNum--;

            //唤醒生产者
            this.notifyAll();
        }else{

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

}