java多线程四：综合实战“生产者-消费者”模型

最新推荐文章于 2021-04-08 14:30:49 发布

一只臭狮子

最新推荐文章于 2021-04-08 14:30:49 发布

阅读量274

点赞数

分类专栏： # java高级特性

原文链接：https://www.jianshu.com/p/9a9fffe5ad66

版权

java高级特性专栏收录该内容

8 篇文章 0 订阅

订阅专栏

文章出处 https://www.jianshu.com/p/9a9fffe5ad66

文章对应视频出处：https://developer.aliyun.com/course/1012?spm=5176.10731542.0.0.6ef2d290hxQ4g0

在多线程的开发过程之中最为著名的案例就是生产者和消费者操作，该操作的主要流程如下：

生产者负责信息内容的生产；
每当生产者生产完成一项完整的信息之后消费者要从这里面取走信息；
如果当生产者没有生产则消费者要等待它生产完成，如果消费者还没有对信息进行消费，则生产者应该等待消费处理完成后再继续生产。

程序的基本实现

可以将生产者和消费者定义为两个独立的线程类对象，但是对于现在生产的数据，可以使用如下的组成：

数据1：title=厨师、content=我做的菜最好吃；
数据2：title=服务员、content=我的服务态度非常好；
既然生产者与消费者是两个独立的线程，那么这两个独立的线程就需要有一个数据的保存集中点，那么可以单独定义一个Message类来实现数据的保存。

范例：程序基本结构

public class ThreadDemo {
    public static void main(String[] args) throws Exception {
        Message msg = new Message();
        new Thread(new Producer(msg)).start();//启动生产者线程
        new Thread(new Consumer(msg)).start();//启动消费者线程
    }
}
class Producer implements Runnable {
    private Message msg;
    public Producer(Message msg) {
        this.msg = msg;
    }
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            if (i % 2 == 0) {
                this.msg.setTitle("厨师");
                try {
                    Thread.sleep(100);//模拟网络延迟
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                this.msg.setContent("我做的菜最好吃");
            } else {
                this.msg.setTitle("服务员");
                try {
                    Thread.sleep(100);//模拟网络延迟
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                this.msg.setContent("我的服务态度非常好");
            }
        }
    }
}
class Consumer implements Runnable {
    private Message msg;
    public Consumer(Message msg) {
        this.msg = msg;
    }
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            try {
                Thread.sleep(10);//模拟网络延迟
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(this.msg.getTitle() + " - " + this.msg.getContent());
        }
    }
}
class Message {
    private String title;
    private String content;

    public String getTitle() {
        return title;
    }
    public void setTitle(String title) {
        this.title = title;
    }
    public String getContent() {
        return content;
    }
    public void setContent(String content) {
        this.content = content;
    }
}

通过整个代码的执行，会发现此时有两个主要问题：

问题1：数据不同步了；
问题2：生产一个取走一个，但是发现有了重复生产和重复取出的问题；

解决数据同步

如果要解决问题，首先解决的就是数据同步的处理问题，如果想要解决数据同步最简单的做法就是使用synchronized关键字定义同步代码块或同步方法，于是这个时候对于同步的处理就可以直接在Message类中完成。
范例：解决同步操作

public class ThreadDemo {
    public static void main(String[] args) throws Exception {
        Message msg = new Message();
        new Thread(new Producer(msg)).start();//启动生产者线程
        new Thread(new Consumer(msg)).start();//启动消费者线程
    }
}
class Producer implements Runnable {
    private Message msg;
    public Producer(Message msg) {
        this.msg = msg;
    }
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            if (i % 2 == 0) {
                this.msg.set("厨师", "我做的菜最好吃");
            } else {
                this.msg.set("服务员", "我的服务态度非常好");
            }
        }
    }
}
class Consumer implements Runnable {
    private Message msg;
    public Consumer(Message msg) {
        this.msg = msg;
    }
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            System.out.println(this.msg.get());
        }
    }
}
class Message {
    private String title;
    private String content;
    public synchronized void set(String title, String content) {
        this.title = title;
        try {
            Thread.sleep(100);//模拟网络延迟
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        this.content = content;
    }
    public synchronized String get() {
        try {
            Thread.sleep(10);//模拟网络延迟
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        return this.title + " - " + this.content;
    }
}

在进行同步处理的时候肯定需要有一个同步的处理对象，那么此时将同步操作交由Message处理是最合适的。这时数据已经可以正常保持一致了，但是对于重复操作的问题依然存在。

线程等待与唤醒

如果说现在想解决生产者与消费者的问题，那么最好的解决方案就是使用等待与唤醒机制。而对于等待与唤醒的操作机制主要依靠是Object类中提供的方法处理的：

等待机制：
1、死等：public final void wait() throws InterruptedException；
2、设置等待时间（毫秒）：public final void wait(long timeout) throws InterruptedException；
3、设置等待时间（纳秒）：public final void wait(long timeout, int nanos) throws InterruptedException；
唤醒第一个等待线程：public final void notify()；
唤醒全部等待线程：public final void notifyAll()；
如果此时有若干个等待线程的话，那么notify()标识的是唤醒第一个等待的，而其他的线程继续等待，而notifyAll()会唤醒所有等待的线程，哪个线程的优先级高就有可能先执行。
对于当前的问题主要的解决应该通过Message类完成处理。
范例：修改Message类

public class ThreadDemo {
    public static void main(String[] args) throws Exception {
        Message msg = new Message();
        new Thread(new Producer(msg)).start();//启动生产者线程
        new Thread(new Consumer(msg)).start();//启动消费者线程
    }
}
class Producer implements Runnable {
    private Message msg;
    public Producer(Message msg) {
        this.msg = msg;
    }
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            if (i % 2 == 0) {
                this.msg.set("厨师", "我做的菜最好吃");
            } else {
                this.msg.set("服务员", "我的服务态度非常好");
            }
        }
    }
}
class Consumer implements Runnable {
    private Message msg;
    public Consumer(Message msg) {
        this.msg = msg;
    }
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            System.out.println(this.msg.get());
        }
    }
}
class Message {
    private String title;
    private String content;
    private boolean flag = true;//表示生产或消费的形式
    //flag = true：允许生产，但不允许消费
    //flag = false：允许消费，但不允许生产
    public synchronized void set(String title, String content) {
        if(this.flag==false){//无法进行生产，应该等待被消费
            try {
                super.wait();
            }catch (Exception e){
                e.printStackTrace();
            }
        }
        this.title = title;
        try {
            Thread.sleep(100);//模拟网络延迟
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        this.content = content;
        this.flag=false;//已经生产过了
        super.notify();//唤醒等待的线程
    }
    public synchronized String get() {
        if(this.flag==true){//还未生产，需要等待
            try {
                super.wait();
            }catch (Exception e){
                e.printStackTrace();
            }
        }
        try {
            Thread.sleep(10);//模拟网络延迟
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        try {
            return this.title + " - " + this.content;
        }finally {//不管如何都要执行
            this.flag=true;//继续生产
            super.notify();//唤醒等待的线程
        }
    }
}

这种处理形式就是在进行多线程开发过程之中最原始的处理方案，整个的等待、同步、唤醒机制都由开发者自行通过原生代码实现控制