黑马程序员技术交流社区

标题: 多线程问题，本来想帮论坛里一哥们解决问题来着，结果把自己绕进去了 [打印本页]
作者: 伊文龙    时间: 2012-6-13 19:11
标题: 多线程问题，本来想帮论坛里一哥们解决问题来着，结果把自己绕进去了
先把代码贴出来
  1. package cn.ywl.extendsdemos;

  3. import java.util.concurrent.locks.Condition;
  4. import java.util.concurrent.locks.Lock;
  5. import java.util.concurrent.locks.ReentrantLock;

  7. public class LockDemo {

  9.         public static void main(String[] args) {

  11.                 Lockc ck = new Lockc();
  12.                 producer p = new producer(ck);
  13.                 consumer c = new consumer(ck);

  15.                 Thread t1 = new Thread(p);
  16.                 Thread t2 = new Thread(p);
  17.                 Thread t3 = new Thread(c);
  18.                 Thread t4 = new Thread(c);

  20.                 t4.start();
  21.                 t2.start();
  22.                 t3.start();
  23.                 t1.start();
  24.         }

  26. }

  28. class Lockc {

  30.         private String name;
  31.         public int cuu = 1;
  32.         private boolean o = false;

  34.         Lock kk = new ReentrantLock();
  35.         Condition ll_1 = kk.newCondition();
  36.         Condition ll_2 = kk.newCondition();

  38.         public void set(String name) throws InterruptedException {
  39.                
  40.                 System.out.println(Thread.currentThread().getName()+"set run!!");
  41.                
  42.                 kk.lock();               
  43.                
  44.                 while (o)
  45.                         try {
  46.                                 System.out.println("set ..... try");
  47.                                 ll_1.await(); // t1 t2
  48.                                 this.name = name + "....." + cuu++;

  50.                                 System.out.println("生产者...................." + this.name+ "..........");
  51.                                 o = true;
  52.                                 ll_2.signal();
  53.                         } finally {
  54.                                 System.out.println("set .....finally!");
  55.                                 kk.unlock();
  56.                         }
  57.                 System.out.println("set over!!!");
  58.         }

  60.         public void out() throws InterruptedException {                        //如果操作这段代码的线程第一个抢到CPU，那么这里就会执行一次
  61.                
  62.                 System.out.println("out run!!!");                               
  63.                
  64.                 kk.lock();                                                                                                               
  65.                                                
  66.                 while (!o)
  67.                         try {
  68.                                 System.out.println(".....");
  69.                                 ll_2.await(); // t3 t4                                                        //!o = true，线程直接 wait了。
  70.                                 System.out.println("消费者" + "...........");
  71.                                 o = false;
  72.                                 ll_1.signal();
  73.                         } finally {
  74.                                 System.out.println("unlock!!!");
  75.                                 kk.unlock();                                                                        //能执行到try里面，当然也能执行到finally里面
  76.                         }
  77.                 System.out.println("set over!!!");
  78.         }
  79. }

  81. class producer implements Runnable {
  82.         private Lockc lo;

  84.         producer(Lockc lo) {
  85.                 this.lo = lo;
  86.         }

  88.         public void run() {

  90.                 while (true) {
  91.                        
  92.                         try {
  93.                                 Thread.sleep(1000);
  94.                         } catch (InterruptedException e1) {
  95.                                 e1.printStackTrace();
  96.                         }
  97.                         // if(lo.cuu>0)
  98.                         try {
  99.                                 lo.set("++商品++");
  100.                         } catch (InterruptedException e) {
  101.                                 e.printStackTrace();
  102.                         }
  103.                 }
  104.         }
  105. }

  107. class consumer implements Runnable {
  108.         private Lockc lo;

  110.         consumer(Lockc lo) {
  111.                 this.lo = lo;
  112.         }

  114.         public void run() {

  116.                 while (true) {
  117.                         try {
  118.                                 Thread.sleep(1000);
  119.                         } catch (InterruptedException e1) {
  120.                                 e1.printStackTrace();
  121.                         }
  122.                         try {
  123.                                 lo.out();
  124.                         } catch (InterruptedException e) {
  125.                                 e.printStackTrace();
  126.                         }
  127.                 }
  128.         }

  130. }
  131. /*
  132. 运行几秒的结果：
  133. out run!!!
  134. .....
  135. Thread-1set run!!
  136. set over!!!
  137. out run!!!
  138. Thread-0set run!!
  139. Thread-1set run!!
  140. set over!!!
  141. Thread-1set run!!
  142. set over!!!
  143. Thread-1set run!!
  144. set over!!!
  145. */
复制代码
关于lock()方法，API中有这样一句：如果锁不可用，出于线程调度目的，将禁用当前线程，并且在获得锁之前，该线程将一直处于休眠状态。

在我这段代码中，第一个拿到kk锁的是消费者线程，为什么生产者线程还可以使用kk.lock();?

难道API中说的禁用当前线程是指的前面获取kk锁的消费者线程？不应该啊。

求解释........
作者: 伊文龙    时间: 2012-6-13 19:40
{:soso_e150:}求解释.......
作者: 伊文龙    时间: 2012-6-14 00:25
帖子马上要沉了。。。自己顶起来。求解释{:soso_e149:}
作者: 孙峰    时间: 2012-6-14 01:12
多线程通信的问题，当一个线程处于睡眠或wait状态时，就会放弃执行资格，同时就释放锁，那么醒着的线程就能拿到锁，并执行了。



欢迎光临 黑马程序员技术交流社区 (http://bbs.itheima.com/) 黑马程序员IT技术论坛 X3.2