黑马程序员技术交流社区

标题: wait 吊起线程的时候 会不会释放synchronized锁呢？求解 [打印本页]
作者: 高梦晓    时间: 2013-4-18 17:47
标题: wait 吊起线程的时候 会不会释放synchronized锁呢？求解
代码如下：
  1. public class Ziyuan<R> {

  3.     private Hashtable<R, Boolean> tab = new Hashtable<R, Boolean>();

  5.     public void add(R r) {
  6.         synchronized (tab) {
  7.             tab.put(r, false);
  8.         }
  9.     }

  11.     //使用这个资源
  12.     public void use(R r) {
  13.         synchronized (tab) {
  14.             if (tab.containsKey(r)) {
  15.                 tab.put(r, true);
  16.                 tab.notifyAll();
  17.             }
  18.         }
  19.     }

  21.     //停止使用资源
  22.     public void release(R r) {
  23.         synchronized (tab) {
  24.             if (tab.containsKey(r)) {
  25.                 tab.put(r, false);
  26.                 tab.notifyAll();
  27.             }
  28.         }
  29.     }

  31.     //关闭系统 需要等待所有资源停止使用
  32.     public void close() throws InterruptedException {
  33.         synchronized (tab) {
  34.             while (true) {
  35.                 boolean able = true;
  36.                 for (R r : tab.keySet()) {
  37.                     if (tab.get(r)) {
  38.                         able = false;
  39.                         break;
  40.                     }
  41.                 }
  42.                 if (!able) {
  43.                     tab.wait(10000);
  44.                 } else {
  45.                     System.out.println("可以关闭了！");
  46.                     break;
  47.                 }
  48.             }
  49.         }
  50.     }
  51. }
复制代码
每次给名为tab的更改哈希表表数据时候 都会用synchronized锁上（布尔Boolean表示是否在使用）,每次操作都会notify其他线程
close的时候 要判断是否所有tab的资源R都为false, 如果有一个资源在使用（有一个为true） 就tab.wait() 等待notify 但是我就是想知道跑 这个wait和notify 和 synchronized 会不会不兼容.....

请问如何设计这个问题？？？

作者: 黑马19我最牛    时间: 2013-4-24 23:20
在多线程中,wait()会让这个线程暂时休眠,sleep()也会让线程休眠,但是不同点在于,在有synchronized锁的时候wait(),让线程休眠的同时会释放这个锁,但是sleep()不会释放锁!
作者: 袁梦希    时间: 2013-4-24 23:26
来顶个帖子，没明白楼主想阐述什么。
作者: 王大斌    时间: 2013-4-24 23:46
import java.io.*;
import java.net.Socket;
import java.util.Date;

import org.apache.commons.beanutils.BeanUtils;


public class Test {

        /**
         * @param args
         */
        public static void main(String[] args) throws Exception
    {
          Object o = new Object();
                  Thread thread = new Thread(new MyRun(o));
                  thread.start();
                  Thread.sleep(2000);
                  while(true)
                  {
                          synchronized(o)
                          {
                                  System.out.println("mainThread");
                          }
                  }
            
            
            
            
        }

}

class MyRun implements Runnable
{
        private Object o;
        public MyRun(Object o)
        {
                this.o = o;
        }
        public void run() {
                // TODO Auto-generated method stub
               
                synchronized(o)
                {
                        try {
                                o.wait();
                        } catch (InterruptedException e) {
                                // TODO Auto-generated catch block
                                e.printStackTrace();
                        }
                   System.out.println("sonThread");
                }
        }
       
       
}


给你写了个例子，你看看

Object o = new Object();
的目的是为了两个线程使用同一对象上的锁
Thread.sleep(2000);
的目的是为了让主线程等待，确保子线程已经执行。
也就是先开始执行

synchronized(o)
                {
                        try {
                                o.wait();
                        } catch (InterruptedException e) {
                                // TODO Auto-generated catch block
                                e.printStackTrace();
                        }
                   System.out.println("sonThread");
                }
当这里 wait 吊起线程的时候 ，你说如果没有 释放synchronized锁
你说主函数中的同步代码块还能进入执行吗？？？



你好好想想，使用1.5之后的Condiction会让你明白的更透彻，现在对象所很少用了



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