import java.util.LinkedList;
import java.util.Queue;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.ReentrantLock; //产品
class Product
{
String name=null;
public Product(String name)
{
this.name=name;
} } class Buffer
{
private Queue<Product> queue=new LinkedList<Product>();//一个普通队列
private final int size=5; //最大长度为,可以自己调整
public void add(Product p)//
{
synchronized (queue) {
while(queue.size()==size)
{
System.out.println(Thread.currentThread().getName()+"队列已经满了,生产者释放锁");
try {
queue.wait();
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
queue.offer(p); System.out.println(Thread.currentThread().getName()+"入队 "+queue.size()); queue.notify(); } } public void remove()
{
synchronized (queue) {
while(queue.size()<=0)
{ System.out.println(Thread.currentThread().getName()+"队列为空,释放锁");
try {
queue.wait();
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
queue.poll();
System.out.println(Thread.currentThread().getName()+"出队,剩下"+queue.size());
queue.notify(); } } }
class Buffer2
{ private Queue<Product> queque=new LinkedList<Product>();
private int size=5;
private ReentrantLock lock=new ReentrantLock(true);
private Condition notFull=lock.newCondition();
private Condition notEmpty=lock.newCondition();
public void add(Product p)
{
lock.lock();
try
{
while(queque.size()==size)
{ notFull.await();
} queque.add(p);
notEmpty.signal();
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}finally
{ lock.unlock();
} }
public void remove()
{
try {
lock.lockInterruptibly();
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
try
{
while(queque.size()==0) notEmpty.await();
queque.poll();
notFull.signal(); } catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}finally{
lock.unlock(); } } } class Producer implements Runnable
{
private Buffer2 buf; public Producer(Buffer2 buf)
{
this.buf=buf;
} @Override
public void run() {
// TODO Auto-generated method stub
for(int i=0;i<10;i++)
{
try {
Thread.sleep(3000); //控制生产速度
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
buf.add(new Product("zhang "+i));
} } }
class Customer implements Runnable
{
private Buffer2 buf=null;
public Customer(Buffer2 buf)
{
this.buf=buf;
}
@Override
public void run() {
for(int i=0;i<10;i++)
{
try {
Thread.sleep(1);//控制生产速度,,
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}//
buf.remove();
} } } public class 生产消费者 { /**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub //学学使用线程池
Buffer2 buf=new Buffer2();
ExecutorService exe=Executors.newCachedThreadPool();
int i=0;
while(i++<2)
{
exe.submit(new Producer(buf)); }
i=0;
while(i++<2)
{
exe.submit(new Customer(buf));
}
exe.shutdown(); } }

  

ReentrantLock Condition 实现消费者生产者问题的更多相关文章

  1. Condition实现一个生产者一个消费者

    Condition实现一个生产者一个消费者,实现一对一交替打印: import java.util.concurrent.locks.Condition; import java.util.concu ...

  2. 【爬虫】Condition版的生产者和消费者模式

    Condition版的生产者和消费者模式 threading.Condition 在没有数据的时候处于阻塞状态,有数据可以使用notify的函数通知等等待状态的线程运作 threading.Condi ...

  3. java并发编程——通过ReentrantLock,Condition实现银行存取款

         java.util.concurrent.locks包为锁和等待条件提供一个框架的接口和类,它不同于内置同步和监视器.该框架允许更灵活地使用锁和条件,但以更难用的语法为代价. Lock 接口 ...

  4. java多线程同步以及线程间通信详解&消费者生产者模式&死锁&Thread.join()(多线程编程之二)

    本篇我们将讨论以下知识点: 1.线程同步问题的产生 什么是线程同步问题,我们先来看一段卖票系统的代码,然后再分析这个问题: package com.zejian.test; /** * @author ...

  5. java 多线程 Thread 锁ReentrantLock;Condition等待与通知;公平锁

    1,介绍: import java.util.concurrent.locks.Lock; import java.util.concurrent.locks.ReentrantLock;   在JA ...

  6. Lock锁与Condition监视器(生产者与消费者)。

    /*生产者与消费者第二次敲,本人表示很郁闷,以后要经常读这个 * Condition 将Object类中的监视器(wait notify notifyAll)分解成不同的对象.例如condition_ ...

  7. java 用condition&reentrylock实现生产者消费者

    package com.lb; import java.util.ArrayList; import java.util.List; import java.util.concurrent.locks ...

  8. Java并发控制:ReentrantLock Condition使用详解

    生产者-消费者(producer-consumer)问题,也称作有界缓冲区(bounded-buffer)问题,两个进程共享一个公共的固定大小的缓冲区.其中一个是生产者,用于将消息放入缓冲区:另外一个 ...

  9. java多线程之消费者生产者模式 (转)

    /*@author shijin * 生产者与消费者模型中,要保证以下几点: * 1 同一时间内只能有一个生产者生产 生产方法加锁sychronized * 2 同一时间内只能有一个消费者消费 消费方 ...

随机推荐

  1. UVA 10795 A Different Task(汉诺塔 递归))

    A Different Task The (Three peg) Tower of Hanoi problem is a popular one in computer science. Briefl ...

  2. map容器对象插入数据的4种方式

    #include <string> #include <iostream>  #include <map>  #include <utility>  u ...

  3. mysql中char与varchar的区别

    在建立数据库表结构的时候,为了给一个String类型的数据定义一个数据库的数据库类型,一般参考的都是char或者varchar,这两种选择有时候让人很纠结,今天想总结一下它们两者的区别,明确一下选择塔 ...

  4. user-agent查询

    浏览器地址栏输入:javascript:window.navigator.userAgent通过网站查询:http://www.enhanceie.com/ua.aspxhttp://www.user ...

  5. Windows下MySQL数据库备份脚本(二)

    说明: MySQL数据库安装目录:C:\Program Files\MySQL\MySQL Server 5.0 MySQL数据库存放目录:C:\Program Files\MySQL\MySQL S ...

  6. 用Python和Django实现多用户博客系统(二)——UUBlog

    这次又更新了一大部分功能,这次以app的形式来开发. 增加博客分类功能:博客关注.推荐功能(ajax实现) 增加二级频道功能 更多功能看截图及源码,现在还不完善,大家先将就着看.如果大家有哪些功能觉的 ...

  7. html 各个标签初始化

    html,body,div,ul,li,ol,h1,h2,h3,h4,h5,h6,span,input{  margin:0;padding:0;}body{font:12px/1.5em " ...

  8. 时序图(Sequence Diagram)

    控制焦点Focus on Control 的取值: Alternative fragment(denoted “alt”) 与 if…then…else对应 Option fragment (deno ...

  9. NCPC 2012 Bread Sorting

    逆序对数的应用: 逆序对数的写法有,二分,树状数组,分治: 学习一下: 树状数组版: 代码: #include<cstdio> #include<cstring> #inclu ...

  10. Tiny210v2( S5PV210 )平台下创建基本根文件系统

    转自Tiny210v2( S5PV210 )平台下创建基本根文件系统 0. 概要介绍 ========================================================= ...