生产者与消费者基本模型——多线程【含代码】

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

过程描述

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

达到生产一个、取走一个的效果

代码实现

将生产者与消费者定义为两个独立的线程类对象

class Producer implements Runnable {
    private Message message;
    public Producer(Message message) {
        this.message = message;
    }
    
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            // 生产张三李四
            if ((i & 1) == 1) {
                // 增加延迟
                try {
                    Thread.sleep(10);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                this.message.setTitle("张三");
                this.message.setContent("今天生了个儿子");
            } else {
                try {
                    Thread.sleep(10);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                this.message.setTitle("李四");
                this.message.setContent("今天生了个女儿");
            }
        }
    }
}

class Consumer implements Runnable {
    private Message message;
    public Consumer(Message message) {
        this.message = message;
    }
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            // 取数据也增加延迟
            try {
                Thread.sleep(10);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(this.message.getTitle() + "    " + this.message.getContent());
        }
    }
}

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

public class Main {
    public static void main(String[] args) {
        Message message = new Message();
        new Thread(new Producer(message)).start();
        new Thread(new Consumer(message)).start();
    }
}

运行结果

从结果看，该程序出现了两个问题

【同步问题】可以发现数据已经不同步了
【重复问题】有重复生产和重复取走

如何解决同步问题？

要解决数据同步问题，就要使用synchronized关键字，将set方法合并，保持数据一致
作如下修改：

class Producer implements Runnable {
    private Message message;
    public Producer(Message message) {
        this.message = message;
    }
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            // 生产张三李四
            if ((i & 1) == 1) {
                // 增加延迟
                try {
                    Thread.sleep(10);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                this.message.set("张三","今天生了个儿子");
            } else {
                try {
                    Thread.sleep(10);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                this.message.set("李四","生了个女儿");
            }
        }
    }
}

class Consumer implements Runnable {
    private Message message;
    public Consumer(Message message) {
        this.message = message;
    }
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            // 取数据也增加延迟
            try {
                Thread.sleep(10);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(this.message.get());
        }
    }
}

class Message {
    private String title;
    private String content;
    public  synchronized void set(String title , String content){
        this.title = title;
        this.content = content;
    }
    public synchronized String get(){
        return  this.title + "    " + this.content;
    }
}

运行结果：

可以看到解决了同步问题
但结果中依然存在 重复问题

如何解决重复问题？

——利用Object类提供的方法
在Message类设置一个标志，有两种状态，第一种状态是允许生产者生产，不允许消费者取走、第二种状态是允许消费者取走，不允许生产者生产

---

使用等待与唤醒机制

• 等待机制：wait()、wait(long time)
• 唤醒机制：notify()——唤醒第一个等待的线程、notifyAll()——唤醒所有等待线程

class Producer implements Runnable {
    private Message message;
    public Producer(Message message) {
        this.message = message;
    }
    
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            // 生产张三李四
            if ((i & 1) == 1) {
                // 增加延迟
                try {
                    Thread.sleep(10);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                this.message.set("张三","今天生了个儿子");
            } else {
                try {
                    Thread.sleep(10);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                this.message.set("李四","生了个女儿");
            }
        }
    }
}

class Consumer implements Runnable {
    private Message message;
    public Consumer(Message message) {
        this.message = message;
    }
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            // 取数据也增加延迟
            try {
                Thread.sleep(10);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(this.message.get());
        }
    }
}

class Message {
    private String title;
    private String content;
    
    /** true : 允许生产，不允许拿走
     *  false : 不允许生产，允许拿走
     * */
    private boolean flag;
    
    public  synchronized void set(String title , String content){
        if(this.flag == false){
            try {
                super.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }else {
            this.title = title;
            this.content = content;
            // 已经生产完成
            this.flag = false;
            // 唤醒正在等待的消费者
            super.notify();
        }
    }
    
    public synchronized String get(){
        if(this.flag == true){
            try {
                super.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        try {
            return  this.title + "    " + this.content;
        }finally {
            this.flag = true;
            super.notify();
        }
    }
}

public class Main {
    public static void main(String[] args) {
        Message message = new Message();
        new Thread(new Producer(message)).start();
        new Thread(new Consumer(message)).start();
    }
}

运行结果：

生产一个，取走一个，成功搞定

---

代码编译器：IntelliJ IDEA 20.02