【java多线程】生产者与消费者多线程同步案例

生产者与消费者

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

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

程序的基本实现

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

• 数据一：title = 王建 、 content = 宇宙大帅哥
• 数据二： title = 小高、 content = 猥琐第一人
  既然生产者与消费者是两个独立的线程，那么这两个独立的线程之间就需要有一个数据保存的集中点，那么单独定义一个Message类实现数据的保存。
  如图：
  
  范例： 程序基本结构

package com.thread;

public class Threademo {
    public static void main(String[] args) {
        Message msg = new Message();
        new Thread(new Producer(msg)).start();
        new Thread(new Customer(msg)).start();
    }
}
/**
 * 中间数据类
 */
class Message{
    private String title;
    private String content;

    public String getContent() {
        return content;
    }

    public String getTitle() {
        return title;
    }

    public void setContent(String content) {
        this.content = content;
    }

    public void setTitle(String title) {
        this.title = title;
    }
}
/**
 * 生产者
 */
class Producer implements Runnable{
    private Message msg;
    public Producer(Message msg) {
        this.msg = msg;
    }

    @Override
    public void run() {
        for(int x = 0; x < 100 ; x ++) {
            if( x % 2 == 0){
                this.msg.setTitle("王建");
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                this.msg.setContent("y宇宙大帅哥");
            } else {
                this.msg.setTitle("小高");
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                this.msg.setContent("猥琐第一个人，保持常态");
            }
        }
    }
}
class Customer implements Runnable{
    private Message msg;
    public Customer(Message msg){
        this.msg = msg;
    }
    @Override
    public void run() {
        for(int x = 0 ; x < 100 ; x ++){
            try {
                Thread.sleep(10);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(this.msg.getTitle() + "," + this.msg.getContent());
        }
    }
}

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

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

解决数据同步

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

package com.thread;
/**
 * 中间数据类
 */
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(){
      return this.title + "," + this.content;
   }
}

public class Threademo {
    public static void main(String[] args) {
        Message msg = new Message();
        new Thread(new Producer(msg)).start();
        new Thread(new Customer(msg)).start();
    }
}

/**
 * 生产者
 */
class Producer implements Runnable{
    private Message msg;
    public Producer(Message msg) {
        this.msg = msg;
    }

    @Override
    public void run() {
        for(int x = 0; x < 100 ; x ++) {
            if( x % 2 == 0){
                this.msg.set("王建","宇宙大帅哥");
            } else {
                this.msg.set("小高","猥琐第一个人，保持常态");
           }
        }
    }
}
class Customer implements Runnable{
    private Message msg;
    public Customer(Message msg){
        this.msg = msg;
    }
    @Override
    public void run() {
        for(int x = 0 ; x < 100 ; x ++){
            System.out.println(this.msg.get());
        }
    }
}

      在进行同步处理的时候肯定需要一个同步的处理对象，那么我们此时肯定要将同步操作交个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类

class Message{
    private String title;
    private String content;
    private boolean flag = true; //生产或消费的形式
  public synchronized void set(String title,String content) {
      if(this.flag == false){
          try {
              super.wait();
          } catch (InterruptedException 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 (InterruptedException e) {
              e.printStackTrace();
          }
      }

       try {
           return this.title + "," + this.content;
       } finally {
           this.flag = true;  // 可以继续生产
           super.notify(); //唤醒线程
       }
   }
}

public class Threademo {
    public static void main(String[] args) {
        Message msg = new Message();
        new Thread(new Producer(msg)).start();
        new Thread(new Customer(msg)).start();
    }
}

/**
 * 生产者
 */
class Producer implements Runnable{
    private Message msg;
    public Producer(Message msg) {
        this.msg = msg;
    }

    @Override
    public void run() {
        for(int x = 0; x < 100 ; x ++) {
            if( x % 2 == 0){
                this.msg.set("王建","宇宙大帅哥");
            } else {
                this.msg.set("小高","猥琐第一个人，保持常态");
           }
        }
    }
}
class Customer implements Runnable{
    private Message msg;
    public Customer(Message msg){
        this.msg = msg;
    }
    @Override
    public void run() {
        for(int x = 0 ; x < 100 ; x ++){
            System.out.println(this.msg.get());
        }
    }
}

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