A股上市公司传智教育(股票代码 003032)旗下技术交流社区北京昌平校区

 找回密码
 加入黑马

QQ登录

只需一步,快速开始

© 黑马朱超 中级黑马   /  2013-3-21 22:04  /  2073 人查看  /  7 人回复  /   0 人收藏 转载请遵从CC协议 禁止商业使用本文

本帖最后由 黑马朱超 于 2013-3-22 18:34 编辑
  1. /**

  2.         jdk 1.5新特性

  3.         javase day12-06 生产者消费者

  4.         两个生产者,两个消费者,一共四个线程的情况

  5.         使用lock替换掉 synchronized;

  6.         使用condition替换掉wait和notify;

  7.         建立两个condition区分等待和唤醒的不同线程

  8. */

  9. import java.util.concurrent.locks.*;

  10. class ProducerConsumerLockDemo

  11. {

  12.         public static void main(String[] args)

  13.                 {

  14.                 Resource r =new Resource();

  15.                 Producer pro1 = new Producer(r);

  16.                 Consumer con1 = new Consumer(r);

  17.                 Thread p1 = new Thread(pro1);

  18.                 Thread p2 = new Thread(pro1);

  19.                 Thread c1 = new Thread(con1);

  20.                 Thread c2 = new Thread(con1);

  21.                 p1.start();

  22.                 p2.start();

  23.                 c1.start();

  24.                 c2.start();

  25.                 }

  26. }



  27. class Resource

  28. {

  29.         private String name;

  30.         private int count =1;

  31.         private boolean flag = false;

  32.         private Lock lock =new ReentrantLock();

  33.        private Condition condition_pro =lock.newCondition();//内嵌的new方法?

  34.       private Condition condition_con =lock.newCondition();

  35.         public void set(String name) throws InterruptedException

  36.         {   

  37.                 lock.lock();

  38.                 try

  39.                 {

  40.                 while(flag)//线程被唤醒时候判断标记,可能造成全部等待

  41.                 condition_pro.await();

  42.                 this.name = name+"---"+count++;

  43.                 System.out.println(Thread.currentThread().getName()+"..生产者.."+this.name);

  44.                 flag =true;

  45.                 condition_con.signal();//唤醒该锁的对方等待线程

  46.                 }

  47.                 finally

  48.                 {

  49.                 lock.unlock();

  50.                 }

  51.         }

  52.         public void out() throws InterruptedException

  53.         {

  54.                 lock.lock();

  55.                 try

  56.                 {

  57.                 while(!flag)

  58.                         condition_con.await();

  59.                 System.out.println(Thread.currentThread().getName()+"..消费者......"+this.name);        

  60.                 flag =false;

  61.                 condition_pro.signal();

  62.                 }

  63.                 finally

  64.                 {

  65.                 lock.unlock();

  66.                 }

  67.         }

  68. }

  69. class Producer implements Runnable

  70. {

  71.         private Resource res;

  72.         Producer(Resource res)

  73.         {

  74.                 this.res = res;

  75.         }

  76.         public void run()

  77.         {

  78.                 int x = 0;

  79.                 while(true)

  80.                 {

  81.                         try

  82.                         {

  83.                         if(x==0)

  84.                             res.set("蛋糕");

  85.                         else

  86.                                 res.set("蛋糕");

  87.                             x = (x+1)%2;

  88.                         }

  89.                         catch(InterruptedException e)

  90.                         {}

  91.                 }

  92.         }

  93. }

  94. class Consumer implements Runnable

  95. {

  96.         private Resource res;

  97.         Consumer(Resource res)

  98.         {

  99.                 this.res = res;

  100.         }

  101.         public void run()

  102.         {

  103.                 while(true)

  104.                 {

  105.                         try

  106.                         {

  107.                                 res.out();

  108.                         }

  109.                                 catch(InterruptedException e)

  110.                         {}

  111.                 }

  112.         }

  113. }





复制代码
private Condition condition_pro =lock.newCondition();
使用lock和condition 编码,代码中红色的东西不理解。有谁对lock.newCondition();这个方法有研究过?是lock对象调用的函数返回一个新的condition么?
也是是看new创建类的对象看惯了,看 这代码不习惯。呵呵。那这右边的应该不算创建新的对象把。?

评分

参与人数 1技术分 +1 收起 理由
陈丽莉 + 1

查看全部评分

7 个回复

倒序浏览
Condition 实例实质上被绑定到一个锁上。要为特定 Lock 实例获得 Condition 实例,就需要调用Lock的newCondition() 方法。Lock是接口我们就使用他的一个ReentrantLock子类来调用newCondition 。
Conditon是接口。其实源代码里面是在 ReentrantLock的内部类中的newCondition方法中new 了一个Condition的子类并返回。
lock.newCondition();是创建一个对象,只不过不是由你创建的而是在源代码中创建的并返回一个Condition对象。
其实这个问题意义不大,想想单例模式不就是直接返回一个对象吗和这个差不多。

评分

参与人数 1技术分 +1 收起 理由
陈丽莉 + 1

查看全部评分

回复 使用道具 举报
Condition是一个接口,这个方法实际返回的是它的一个实例.
Condition 实例实质上被绑定到一个锁上。要为特定 Lock 实例获得 Condition 实例,就要使用其 newCondition() 方法。
也就是说不让你自己new 而是提供一个方法给你,这个方法返回的是一个Condition的对象.没什么难理解吧.

评分

参与人数 1技术分 +1 收起 理由
陈丽莉 + 1

查看全部评分

回复 使用道具 举报
lock.newCondition();是lock对象,调用newCondition()方法,newCondition()返回一个实例。

评分

参与人数 1技术分 +1 收起 理由
陈丽莉 + 1

查看全部评分

回复 使用道具 举报
罗玉宁 发表于 2013-3-22 03:13
Condition 实例实质上被绑定到一个锁上。要为特定 Lock 实例获得 Condition 实例,就需要调用Lock的newCond ...

恩,就和单例设计模式一样一样的。
回复 使用道具 举报
这个是问题是 ReentrantLock对象lock调用ReentrantLock中的newCondition()方法,返回一个Condition的一个子类对象。
并且这个Condition的子类对象与这个锁相关联
不过我跟楼上有些不同见解  
我不认为这个是单例模式  单例模式返回的始终是同一个对象
而这个 ReentrantLock对象lock每次调用一次newCondition()方法返回的对象是一个新的对象

private Condition condition_pro =lock.newCondition();
private Condition condition_con =lock.newCondition();  这两句  condition_pro    condition_con   是两个不同的对象  并与lock这个锁相关联

正式因为这个Lock接口能够关联多个Condition的子类对象 所以才引入的这个知识点 解决不同进程见得等待和唤醒问题   
所以说 我感觉这个与单例模式并不相同 但内部实质还是new了Contion的子类对象 并与这个锁相关联

评分

参与人数 1技术分 +1 收起 理由
陈丽莉 + 1

查看全部评分

回复 使用道具 举报
记得及时处理帖子哦,继续追问,或将分类改成【已解决】~
回复 使用道具 举报
刘凯 发表于 2013-3-22 12:14
这个是问题是 ReentrantLock对象lock调用ReentrantLock中的newCondition()方法,返回一个Condition的一个子 ...

恩。单例设计模式只能建立一个类的对象,这点有区别,呵呵
回复 使用道具 举报
您需要登录后才可以回帖 登录 | 加入黑马