【java多线程】生产者与消费者多线程同步案例
本文共 6083 字，大约阅读时间需要 20 分钟。
文章目录
生产者与消费者
在多线程的开发过程之中最为著名的案例就是生产者与消费者操作，该操作的主要流程如下：
- 生产者负责信息内容的生产；
- 每当生产者生产完成一项完整的信息之后消费者要从这里取走信息；
- 如果生产者没有完成生产则消费者要等待它完成生产，如果消费者还没有进行消费，则生产者应该等待消费处理完成后再继续生产。
程序的基本实现
可以将生产者与消费者定义为两个独立的线程类对象，但是对于现在生产的数据，可以使用如下的组成：
- 数据一：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()); } }} 这种处理形式就是在进行多线程开发过程中最原始的处理方案，整个的等待、同步、唤醒机制都是由开发者自行通过原生代码实现控制。
转载地址：http://wnfoi.baihongyu.com/
你可能感兴趣的文章
SQL行转列汇总
查看>>
sqlserver、db2、oracle存储过程动态sql语句示例
查看>>
DB2和oracle以及MS的SQL Server比
查看>>
jsf中xhtml文件访问
查看>>
数据库中CHAR，VARCHAR，TEXT等字段的区别
查看>>
greenplum 与 hbase的区别
查看>>
String、StringBuffer与StringBuilder之间区别
查看>>
Elasticsearch、MongoDB和Hadoop比较
查看>>
Elasticsearch与hadoop比较
查看>>
外地人一年内直接落户上海
查看>>
测试用例设计--因果图
查看>>
Kafka 对比 ActiveMQ
查看>>
架构以及我理解中架构的本质
查看>>
如何将Lucene索引写入Hadoop1.x的HDFS系统
查看>>
标量数据类型
查看>>
Lucene 或者 solr 有什么不一样
查看>>
MapReduce来构建索引
查看>>
Lucene和Solr从数据库加载词库分析
查看>>
CSS 让div内的span在一行显示
查看>>
Angularjs 实例
查看>>