Dear Doug,
    My friend forward your kindly reply to me (quoted below), we know
that the HashMap is not thread safe, but I'm curious about possibility
of using HashMap as a cache: if the concurrent putting happened, as
long as it putting the same key, the HashMap.get(key) method in other
reader threads should only return one of these concurrrent putting
objects, shouldn't throw any exceptions. Is it right?
    
    public Long getTemperature(String city) {
        Long result = (Long) _tempCache.get(city);
        if (result == null) {
            result = calcTemperature(city);
            _tempCache.put(city, result);
        }
        return result;
    }
        
Regards,
--Readonly

No. The internals of HashMap are not consistently read-only
concurrently accessible. Which means that you can possibly read
completely incorrect values while the table is being modified.

-Doug

Dear Doug,
    Deeply appreciated your prompt reply.
    
    I write some code, try to simulate the concurrent putting (detail
below), but can not get a completely incorrect value as you mentioned
, would you please specify any flaws in this code? My testing
environment is j2sdk1.4.1 on win2000.


import java.util.HashMap;
import java.util.Map;

/**
 * @author Quake Wang
 * @since 2004-11-1
 * @version $Revision: 1.0 $
 */
public class HashMapCache {
    private static final Map _cache = new HashMap();

    public static void main(String[] args) {
        for (int i = 0; i <= 10; i++) {
            final Long temp = new Long(i);
            new Thread() {
                public void run() {
                    while (true) {
                        _cache.put("NY", temp);
                    }
                }
            }.start();
        }

        for (int i = 0; i <= 10; i++) {
            new Thread() {
                public void run() {
                    while (true) {
                        Long cachedTemp = (Long) _cache.get("NY");
                        //if concurrent putting break the cached value, 
will we
                        // get a completely incorrect value?
                        if (cachedTemp.longValue() > 10 ||
cachedTemp.longValue() < 0) {
                            System.out.println(cachedTemp);
                        }
                    }
                }
            }.start();
        }
    }

}

Regards,

HashMap is not threadsafe, so you already know that there are some
sequences of actions will cause it to fail when accessed by multiple
threads. There is no reason for you to try to replicate them -- even
if some sequences work out OK, small variations of them will
not. 

Instead, use a thread-safe map. The ConcurrentHashMap class has access
times that are about as fast as HashMap, but is known to be safe, so
you should use it.

-Doug

public class CacheData {
    public static java.util.Map cache;

    public synchronized static void initCache() {
        CacheData.cache = new java.util.HashMap();
    }
    public synchronized static String putCacheData(String key,String value){
        CacheData.cache.put(key,value);
        return value;
    }
    public static String getCacheDataByKey(String key, String defValue) {
        if (cache == null) {
            CacheData.initCache();
        }
        if (!cache.containsKey(key)){
            return putCacheData(key,defValue);
        }
       return (String)cache.get(key);
    }

    public static void main(String[] args) {
        CacheData cachedata = new CacheData();
    }
}