Java多线程技术~生产者和消费者问题

Java多线程技术~生产者和消费者问题

本文是上一篇文章的后续,详情点击该连接

线程通信

应用场景：生产者和消费者问题

       假设仓库中只能存放一件产品，生产者将生产出来的产品放入仓库，消费者将仓库中产品取走消费

       如果仓库中没有产品，则生产者将产品放入仓库，否则停止生产并等待，直到仓库中的产品被消费者取走为止

       如果仓库中放有产品，则消费者可以将产品取走消费，否则停止消费并等待，直到仓库中再次放入产品为止

分析

       这是一个线程同步问题，生产者和消费者共享同一个资源，并且生产者和消费者之间相互依赖，互为条件

       对于生产者，没有生产产品之前，要通知消费者等待。而生产了产品之后，又需要马上通知消费者消费

       对于消费者，在消费之后，要通知生产者已经消费结束，需要继续生产新产品以供消费

       在生产者消费者问题中，仅有synchronized是不够的

              synchronized可阻止并发更新同一个共享资源，实现了同步

              synchronized不能用来实现不同线程之间的消息传递（通信）

方法名	作用
final void wait()	表示线程一直等待，直到其它线程通知
void wait(long timeout)	线程等待指定毫秒参数的时间
final void wait(long timeout,int nanos)	线程等待指定毫秒、微妙的时间
final void notify()	唤醒一个处于等待状态的线程
final void notifyAll()	唤醒同一个对象上所有调用wait()方法的线程，优先级别高的线程优先运行

消费者,生产者线程代码实现

package com.alvin.test;

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

public class Test {
    public static void main(String[] args){
        //创建共享资源对象
        Shop shop = new Shop();
        //创建生产者
        Boss boss = new Boss(shop);
        //创建消费者
        Customer customer = new Customer(shop);
        //启动线程
        new Thread(boss).start();
        new Thread(customer).start();
    }
}

//生产者类
class Boss implements Runnable{
    private Shop shop;
    public Boss(Shop shop){
        this.shop = shop;
    }
    @Override
    public void run() {
        for(int i = 1; i < 100; i++){
            if(i % 2 == 0){
                shop.Set("OPPO","reno 3 Pro");
            }else{
                shop.Set("HUWEI","Mate 30 Pro");
            }
        }
    }
}

//消费者类
class Customer implements Runnable{
    private Shop shop;
    public Customer(Shop shop){
        this.shop = shop;
    }
    @Override
    public void run() {
        for(int i = 1; i < 100; i++){
            shop.Get();
        }
    }
}

//商品类
class Shop{
    private String brand;       //商品品牌
    private String name;        //商品名称
    private boolean flag = false; //默认没有商品

  // 编写一个赋值的方法  同步监视器为Shop类的对象
    public synchronized void Set(String brand, String name){
        //先判断下有没有商品
        if(flag){
            try {
                //生产者线程等待
                super.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        //当生产者线程被唤醒后从wait()之后的代码开始执行
        //生产商品
        this.brand = brand;
        try {
            Thread.sleep(300);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        this.name = name;
        System.out.println("老板: 今天厂里生产了 " + brand + " " + name + " 欢迎下次光临!----------");
        //通知消费者
        super.notify();
        flag = true;
    }

    //编写一个取值的方法
    public synchronized void Get(){
        //先判断下有没有商品
        if(!flag){
            try {
                super.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        System.out.println("----------顾客: " + brand + " " + name + " 已经买到手,谢谢老板!");
        //通知生产者
        super.notify();
        flag = false;
    }
}

线程同步的细节

       进行线程通信的多个线程，要使用同一个同步监视器（product），还必须要调用该同步监视器的wait()、notify()、notifyAll();

wait()等待

       在【其他线程】调用【此对象】的 notify() 方法或 notifyAll() 方法前，导致当前线程等待。换句话说，此方法的行为就好像它仅执行 wait(0) 调用一样。当前线程必须拥有此对象监视器

wait(time) 等待

       在其他线程调用此对象的 notify() 方法或 notifyAll() 方法，或者超过指定的时间量前，导致当前线程等待。 当前线程必须拥有此对象监视器。

notify() 通知 唤醒

       唤醒在【此对象监视器】上等待的【单个】线程。如果所有线程都在此对象上等待，则会选择唤醒其中一个线程。【选择是任意性的】，并在对实现做出决定时发生

notifyAll() 通知所有 唤醒所有

       唤醒在【此对象监视器】上等待的【所有】线程。被唤醒的线程将以常规方式与在该对象上主动同步的其他所有线程【进行竞争】；

完整的线程生命周期

阻塞状态有三种

       普通的阻塞 sleep,join,Scanner input.next()

       同步阻塞（锁池队列） 没有获取同步监视器的线程的队列

       等待阻塞（阻塞队列） 被调用了wait()后释放锁，然后进行该队列

sleep()和wait()的区别

       区别1:sleep() 线程会让出CPU进入阻塞状态，但不会释放对象锁 wait() 线程会让出CPU进入阻塞状态， 【也会放弃对象锁】，进入等待【此对象】的等待锁定池

       区别2: 进入的阻塞状态也是不同的队列

       区别3：wait只能在同步控制方法或者同步控制块里面使用，而sleep可以在任何地方使用

使用新一代的Lock实现线程通信

       之前实现线程通信时，是生产者和消费者在一个等待队列中，会存在本来打算唤醒消费者，却唤醒一个生产者的问题，能否让生产者和消费者线程在不同的队列中等待呢？在新一代的Lock中提供这种实现方式。

package com.alvin.test;

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

public class Test {
    public static void main(String[] args){
        //创建共享资源对象
        Shop shop = new Shop();
        //创建生产者
        Boss boss = new Boss(shop);
        //创建消费者
        Customer customer = new Customer(shop);
        //启动线程
        new Thread(boss).start();
        new Thread(customer).start();
    }
}

//生产者类
class Boss implements Runnable{
    private Shop shop;
    public Boss(Shop shop){
        this.shop = shop;
    }
    @Override
    public void run() {
        for(int i = 1; i < 100; i++){
            if(i % 2 == 0){
                shop.Set("OPPO","reno 3 Pro");
            }else{
                shop.Set("HUWEI","Mate 30 Pro");
            }
        }
    }
}

//消费者类
class Customer implements Runnable{
    private Shop shop;
    public Customer(Shop shop){
        this.shop = shop;
    }
    @Override
    public void run() {
        for(int i = 1; i < 100; i++){
            shop.Get();
        }
    }
}

//商品类
class Shop{
    private String brand;       //商品品牌
    private String name;        //商品名称
    private boolean flag = false;//默认没有商品

    private Lock lock = new ReentrantLock();
    Condition boss = lock.newCondition();       //用于生产者
    Condition customer = lock.newCondition();   //用于消费者

    // 编写一个赋值的方法  同步监视器为Shop类的对象
    public  void Set(String brand, String name){
        lock.lock();
        try {
            //先判断下有没有商品
            if (flag) {
                try {
                    //生产者线程等待
                    boss.await();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            //当生产者线程被唤醒后从wait()之后的代码开始执行
            //生产商品
            this.brand = brand;
            try {
                Thread.sleep(300);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            this.name = name;
            System.out.println("老板: 今天厂里生产了 " + brand + " " + name + " 欢迎下次光临!----------");
            //通知消费者
            customer.signalAll();
            flag = true;
        }finally {
            //解锁
            lock.unlock();
        }
    }

    //编写一个取值的方法
    public  void Get(){
        lock.lock();
        try {
            //先判断下有没有商品
            if (!flag) {
                try {
                    //消费者等待
                    customer.await();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            System.out.println("----------顾客: " + brand + " " + name + " 已经买到手,谢谢老板!");
            //通知生产者
            boss.signalAll();
            flag = false;
        }finally {
            //解锁
            lock.unlock();
        }
    }
}

Condition

       Condition是在Java 1.5中才出现的，它用来替代传统的Object的wait()、notify()实现线程间的协作，相比使用Object的wait()、notify()，使用Condition1的await()、signal()这种方式实现线程间协作更加安全和高效。

       它的更强大的地方在于：能够更加精细的控制多线程的休眠与唤醒。对于同一个锁，我们可以创建多个Condition，在不同的情况下使用不同的Condition 一个Condition包含一个等待队列。一个Lock可以产生多个Condition，所以可以有多个等待队列。

       在Object的监视器模型上，一个对象拥有一个同步队列和等待队列，而Lock（同步器）拥有一个同步队列和多个等待队列。

       Object中的wait(),notify(),notifyAll()方法是和"同步锁"(synchronized关键字)捆绑使用的；而Condition是需要与"互斥锁"/"共享锁"捆绑使用的。

       调用Condition的await()、signal()、signalAll()方法，都必须在lock保护之内，就是说必须在lock.lock()和lock.unlock之间才可以使用

---

       Conditon中的await()对应Object的wait()；

       Condition中的signal()对应Object的notify()；

       Condition中的signalAll()对应Object的notifyAll()。

void await() throws InterruptedException

       造成当前线程在接到信号或被中断之前一直处于等待状态。 与此 Condition 相关的锁以原子方式释放，并且出于线程调度的目的，将禁用当前线程，且在发生以下四种情况之一 以前，当前线程将一直处于休眠状态。

       其他某个线程调用此 Condition 的 signal() 方法，并且碰巧将当前线程选为被唤醒的线程；或者 其他某个线程调用此 Condition 的 signalAll() 方法；或者其他某个线程中断当前线程，且支持中断线程的挂起；或者发生“虚假唤醒”

       在所有情况下，在此方法可以返回当前线程之前，都必须重新获取与此条件有关的锁。在线程返回时，可以保证它保持此锁。

void signal()

       唤醒一个等待线程。

       如果所有的线程都在等待此条件，则选择其中的一个唤醒。在从 await 返回之前，该线程必须重新获取锁。

void signalAll()

       唤醒所有等待线程。

       如果所有的线程都在等待此条件，则唤醒所有线程。在从 await 返回之前，每个线程都必须重新获取锁。