1. import java.util.Collection;
   
2.         import java.util.HashMap;
   
3.         import java.util.Iterator;
   
4.         import java.util.Map;
   
5.         import java.util.Random;
   
6.         import java.util.Set;
   
7.         import java.util.concurrent.locks.ReentrantReadWriteLock;
   
8.        
   
9.         public class CacheItem {
   
10.        
    
11.                 private static Map<String ,Object> cache = new HashMap<String ,Object>();
    
12.                 private static ReentrantReadWriteLock readWriteLock = new ReentrantReadWriteLock();
    
13.                 public static Object getObject(String key,Object target){
    
14.                         readWriteLock.readLock().lock();
    
15.                         Object polixy = null;       
    
16.                         try{
    
17.                                 polixy = cache.get(key);
    
18.                                 if(polixy==null){
    
19.                                         readWriteLock.readLock().unlock();       
    
20.                                         readWriteLock.writeLock().lock();
    
21.                                         try{
    
22.                                         if(polixy==null){
    
23.                                           polixy = target;
    
24.                                           cache.put(key, polixy);
    
25.                                         }       
    
26.                                  }
    
27.                                   finally{
    
28.                                         readWriteLock.writeLock().unlock();
    
29.                                   }
    
30.                            }
    
31.                                 readWriteLock.readLock().lock();               
    
32.                         }
    
33.                         finally{
    
34.                                 readWriteLock.readLock().unlock();
    
35.                         }       
    
36.                  return polixy;                       
    
37.           }
    
38.                
    
39.                 public static void main(String[] args) {
    
40.                        
    
41.                   for(int i=0;i<10;i++){
    
42.                          final int count = i;
    
43.                          new Thread(new Runnable(){
    
44.        
    
45.                                 @Override
    
46.                                 public void run() {
    
47.                                          System.out.println(Thread.currentThread().getName()+" ::: "+count+" ::: "+CacheItem.getObject(String.valueOf(count), new Random().nextInt(1000)));       
    
48.                                 }
    
49.                                  
    
50.                          }).start();  
    
51.                   }
    
52.                                                             
    
53.                          for(Map.Entry<String, Object>  itdemo : cache.entrySet()){
    
54.                                  System.out.println("key="+itdemo.getKey()+","+"value="+itdemo.getValue());  // 结果不是预期想要了，要么少了几个element ,要么并发修改异常.....崩溃了
    
55.                          }
    
56.                          
    
57.                          System.out.println(cache.toString());

复制代码

若能很好了解决方法，有奖励哟....{:soso_e113:}

注意：程序代码后面少了两个  } }  ，是我的失误...{:soso_e127:}

你是不是要这样的结果？

1. package ClassTest;
   
2. 
   
3. import java.util.Collection;
   
4. import java.util.HashMap;
   
5. import java.util.Iterator;
   
6. import java.util.Map;
   
7. import java.util.Random;
   
8. import java.util.Set;
   
9. import java.util.concurrent.locks.ReentrantReadWriteLock;
   
10. 
    
11. public class CacheItem {
    
12. 
    
13.         private static Map<String, Object> cache = new HashMap<String, Object>();
    
14.         private static ReentrantReadWriteLock readWriteLock = new ReentrantReadWriteLock();
    
15. 
    
16.         public static Object getObject(String key, Object target) {
    
17.                 readWriteLock.readLock().lock();
    
18.                 Object polixy = null;
    
19.                 try {
    
20.                         polixy = cache.get(key);
    
21.                         if (polixy == null) {
    
22.                                 readWriteLock.readLock().unlock();
    
23.                                 readWriteLock.writeLock().lock();
    
24.                                 try {
    
25.                                         if (polixy == null) {
    
26.                                                 polixy = target;
    
27.                                                 cache.put(key, polixy);
    
28.                                         }
    
29.                                 } finally {
    
30.                                         readWriteLock.writeLock().unlock();
    
31.                                 }
    
32.                         }
    
33.                         readWriteLock.readLock().lock();
    
34.                 } finally {
    
35.                         readWriteLock.readLock().unlock();
    
36.                 }
    
37.                 return polixy;
    
38.         }
    
39. 
    
40.         //将循环封装到一个线程里
    
41.         class Thr extends Thread {
    
42.                 public void run() {
    
43.                         for (int i = 0; i < 10; i++) {
    
44.                                 final int count = i;
    
45.                                 new Thread(new Runnable() {
    
46. 
    
47.                                         @Override
    
48.                                         public void run() {
    
49.                                                 System.out.println(Thread.currentThread().getName()
    
50.                                                                 + " ::: "
    
51.                                                                 + count
    
52.                                                                 + " ::: "
    
53.                                                                 + CacheItem.getObject(String.valueOf(count),
    
54.                                                                                 new Random().nextInt(1000)));
    
55.                                         }
    
56. 
    
57.                                 }).start();
    
58.                         }
    
59.                 }
    
60.         }
    
61. 
    
62.         public static void main(String[] args) throws InterruptedException {
    
63. 
    
64.                 //让这个线程优先执行
    
65.                 Thread t = new CacheItem().new Thr();
    
66.                 t.run();
    
67.                 t.join();
    
68. 
    
69.                 //由于线程必须执行完集合中值才完整所以必须让这个在循环之后执行
    
70.                 for (Map.Entry<String, Object> itdemo : cache.entrySet()) {
    
71.                         System.out.println("key=" + itdemo.getKey() + "," + "value="
    
72.                                         + itdemo.getValue()); // 结果不是预期想要了，要么少了几个element
    
73.                                                                                         // ,要么并发修改异常.....崩溃了
    
74.                 }
    
75. 
    
76.                 System.out.println(cache.toString());
    
77.         }
    
78. }

复制代码

许鑫星 发表于 2013-3-8 00:03
你是不是要这样的结果？

貌似这种写法还行....，不过我用CountDownLatch，可惜，我给不了金币...让斑竹给你技术分吧;P