本例定义了4个类,这里说一下,方便下面讲解。分别是Product(产品),Producer(生产者),Consumer(消费者), Test(测试类)。

多线程之间通信与共享数据只要引用同一内存区域就可以了,做法就是new一个对象,传多个引用。

 Product pro = new Product();
Producer producer = new Producer(pro);
Consumer consumer = new Consumer(pro);

但是由于cpu的随机性,共享数据时容易出现非法数据,这个不必多说了。解决办法就是线程同步,在一个线程对共享的数据访问完之前,不允许另一个线程访问。

但是如果代码写成下面这样,则会出现死锁问题。(虽然本例使用的循环队列容量比较大,一般不会出现,不过这确实是安全隐患)

 public class Product {

     private boolean[] pro = new boolean[100];
private int head = 0;
private int rear = 0; public synchronized void production() {
while((rear + 1) % 100 == head) {
try {
this.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
System.out.println("生产了一件产品, 放在位置 : " + rear);
pro[rear] = true;
rear = (rear + 1) % 100;
this.notify();
} public synchronized void consume() {
while(rear == head) {
try {
this.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
System.out.println("消费了一件产品, 来自位置 : " + head);
pro[head] = false;
head = (head + 1) % 100;
this.notify();
}
}

上面代码判断时用的while而不是if(同步代码中使用while代替if是一种技巧),这样避免判断完成之后cpu切换到另一线程,切换回来时由于没有再次判断,容易造成非法数据的问题。

解决死锁的第一种方案是使用synchronized和object中的各种方法,需要notifyAll代替notify,避免当队列已满且消费者全都wait时,生产者无法生产,造成死锁问题;第二种方案是使用Lock接口和Condition接口,可以用与第一种同样的方法,还可以利用Condition的多监视器绑定的特性,为生产者和消费者分别设置不同的监视器,这样保证生产者唤醒消费者,消费者唤醒生产者,就不会出现死锁问题了。

给出解决后的代码:

 public class Product {

     private boolean[] pro = new boolean[100];
private int head = 0;
private int rear = 0; public synchronized void production() {
while((rear + 1) % 100 == head) {
try {
this.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
System.out.println("生产了一件产品, 放在位置 : " + rear);
pro[rear] = true;
rear = (rear + 1) % 100;
this.notifyAll();
} public synchronized void consume() {
while(rear == head) {
try {
this.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
System.out.println("消费了一件产品, 来自位置 : " + head);
pro[head] = false;
head = (head + 1) % 100;
this.notifyAll();
}
}
 import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock; public class Product2 { private boolean[] pro = new boolean[100];
private int head = 0;
private int rear = 0;
Lock lock = new ReentrantLock();
Condition production_con = lock.newCondition();
Condition consume_con = lock.newCondition(); public void production() {
lock.lock();
while((rear + 1) % 100 == head) {
try {
production_con.await();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
try {
System.out.println("生产了一件产品, 放在位置 : " + rear);
pro[rear] = true;
rear = (rear + 1) % 100;
consume_con.signalAll();
} finally {
lock.unlock();
}
} public void consume() {
lock.lock();
while(rear == head) {
try {
consume_con.await();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
try {
System.out.println("消费了一件产品, 来自位置 : " + head);
pro[head] = false;
head = (head + 1) % 100;
production_con.signalAll();
} finally {
lock.unlock();
}
}
}

最后贴上Producer,Consumer,Test三个类的代码

 public class Producer implements Runnable {
private Product pro;
public Producer(Product pro) {
this.pro = pro;
}
public void run() {
for(int i = 0; i < 100; i++) {
pro.production();
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
 public class Consumer implements Runnable {
private Product pro;
public Consumer(Product pro) {
this.pro = pro;
}
public void run() {
for(int i = 0; i < 100; i++) {
pro.consume();
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
 public class Test {

     public static void main(String[] args) {
//为了方便阅读,没有用匿名类
Product pro = new Product();
Producer producer = new Producer(pro);
Consumer consumer = new Consumer(pro);
Thread p1 = new Thread(producer);
Thread p2 = new Thread(producer);
Thread c1 = new Thread(consumer);
Thread c2 = new Thread(consumer);
p1.start();
p2.start();
c1.start();
c2.start();
}
}

Java笔记1 : 在生产者消费者模式中,线程通信与共享数据,死锁问题与解决办法的更多相关文章

  1. java 多线程 22 :生产者/消费者模式 进阶 利用await()/signal()实现

    java多线程15 :wait()和notify() 的生产者/消费者模式 在这一章已经实现了  wait/notify 生产消费模型 利用await()/signal()实现生产者和消费者模型 一样 ...

  2. 生产者消费者模式中条件判断是使用while而不是if

    永远在循环(loop)里调用 wait 和 notify,不是在 If 语句现在你知道wait应该永远在被synchronized的背景下和那个被多线程共享的对象上调用,下一个一定要记住的问题就是,你 ...

  3. JAVA多线程编程之生产者消费者模式

    Java中有一个BlockingQueue可以用来充当堵塞队列,下面是一个桌面搜索的设计 package net.jcip.examples; import java.io.File; import ...

  4. java ReentrantLock结合条件队列 实现生产者-消费者模式 以及ReentratLock和Synchronized对比

    package reentrantlock; import java.util.ArrayList; public class ProviderAndConsumerTest { static Pro ...

  5. java设计模式之生产者/消费者模式

    什么是生产者/消费者模式? 某个模块负责产生数据,这些数据由另一个模块来负责处理(此处的模块是广义的,可以是类.函数.线程.进程等).产生数据的模块,就形象地称为生产者:而处理数据的模块,就称为消费者 ...

  6. Java并发程序设计(十一)设计模式与并发之生产者-消费者模式

    设计模式与并发之生产者-消费者模式 生产者-消费者模式是一个经典的多线程设计模式.它为多线程间的协作提供了良好的解决方案.在生产者-消费者模式中,通常由两类线程,即若干个生产者线程和若干个消费者线程. ...

  7. 使用BlockingQueue的生产者消费者模式

    BlockingQueue很好的解决了多线程中,如何高效安全“传输”数据的问题.通过这些高效并且线程安全的队列类,为我们快速搭建高质量的多线程程序带来极大的便利.使用场景. 首先它是一个队列,而一个队 ...

  8. Java 学习笔记 使用并发包ReentrantLock简化生产者消费者模式代码

    说明 ReentrantLock是java官方的一个线程锁类,ReentarntLock实现了Lock的接口 我们只需要使用这个,就可以不用使用synchronized同步关键字以及对应的notify ...

  9. 2.5多线程(Java学习笔记)生产者消费者模式

    一.什么是生产者消费者模式 生产者生产数据存放在缓冲区,消费者从缓冲区拿出数据处理. 可能大家会问这样有何好处? 1.解耦 由于有了缓冲区,生产者和消费者之间不直接依赖,耦合度降低,便于程序拓展和维护 ...

随机推荐

  1. gulp自己主动化任务脚本在HybridApp开发中的使用

    眼下做前端开发的同学可能都熟悉grunt.fis之类的自己主动化构建工具.事实上在HybridApp开发中我们也能够使用这些工具来简化我们的工作.gulp就是一个比grunt,fis都先进的构建工具. ...

  2. Redis学习手册(Hashes数据类型)

    一.概述: 我们可以将Redis中的Hashes类型看成具有String Key和String Value的map容器.所以该类型非常适合于存储值对象的信息.如Username.Password和Ag ...

  3. DNS 和 IPv6 配置攻略

    Windows 2003 DNS配置攻略 http://lgzeng2360.blog.51cto.com/275998/161908/ http://ask.zol.com.cn/q/21861.h ...

  4. UPDATE sql 优化

    一个网友说他的存储过程中有一段update sql,运行了15分钟还没出结果,需要优化一下 他把sql发给我 UPDATE TB_RESULT R SET R.VOTE_COUNT=NVL(( SEL ...

  5. mysql配置优化

    [笔记]MySQL 配置优化   安装MySQL后,配置文件my.cnf在 /MySQL安装目录/share/mysql目录中,该目录中还包含多个配置文件可供参考,有my-large.cnf ,my- ...

  6. Eclipse SVN插件账号、密码修改

    操作系统:win7 svn插件:Window -> Preferences -> Team -> SVN 修改方式: 1,删除C:\Users\用户名\AppData\Roaming ...

  7. JS 时间与时间戳的相互转换

    <script type="text/javascript"> var time = "2015-04-22 21:41:43";//2015-4- ...

  8. Spring 3.0 + Atomikos构建jta分布式事务

    Spring3.0已经不再支持jtom了,不过我们可以用第三方开源软件atomikos(http://www.atomikos.com/)来实现.Atomikos是目前在分布式事务管理中做得相当不错的 ...

  9. NET环境下的未处理异常(unhandled exception)的解决方案

    NET环境下的未处理异常(unhandled exception )的解决方案 .Net 框架提供了非常强大的异常处理机制,同时对一些非托管代码很难控制的系统问题比如指针越界,内存泄漏等提供了很好的解 ...

  10. JS七种加密解密方法

    http://www.cnblogs.com/mq0036/p/4983858.html HTML或JS加密解密 本文一共介绍了七种方法:   一:最简单的加密解密   二:转义字符"\&q ...