代码如下：

1. public class Ziyuan<R> {
   
2. 
   
3.     private Hashtable<R, Boolean> tab = new Hashtable<R, Boolean>();
   
4. 
   
5.     public void add(R r) {
   
6.         synchronized (tab) {
   
7.             tab.put(r, false);
   
8.         }
   
9.     }
   
10. 
    
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.     }
    
20. 
    
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.     }
    
30. 
    
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 会不会不兼容.....

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

在多线程中,wait()会让这个线程暂时休眠,sleep()也会让线程休眠,但是不同点在于,在有synchronized锁的时候wait(),让线程休眠的同时会释放这个锁,但是sleep()不会释放锁!

来顶个帖子，没明白楼主想阐述什么。

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会让你明白的更透彻，现在对象所很少用了