请问我这段业务如何用double check lock 做同步处理

private volatile static ConcurrentHashMap> cacheClass=new ConcurrentHashMap>();

List classes=cacheClass.get(classPrefix);
if(null == classes) {
classes=new ArrayList();
classTo=new ClassTO(classKey);
} else {
for(ClassTO tmp: classes) {
if(classKey.equals(tmp.getKey())) {
classTo=tmp;
break;
}
}
}

methodTo=classTo.get(methodAndParamskey);
if(null == methodTo) {
methodTo=new MethodTO(methodAndParamskey);
}

doCache(result, data, methodTo, method);
classTo.add(methodTo);
CacheHandler.getCacheInstance().set(methodAndParamskey, data.getExpiration(), methodTo);
classes.add(classTo);
cacheClass.put(classPrefix, classes);

是的，ConcurrentHashMap本来就是线程安全的。不需要再控制了~
现在并发编程一般建议采用java concurrent API,它是语句块级别的控制。毕竟是大牛编写的,已经封装的很好了~ 没有必要再用原生的方式了撒！即费事又费时，还有可能不讨好，哈哈~ 8)

亲，互斥一把中不中？
[code="java"]
Lock lock = new ReentrantLock();

List classes=cacheClass.get(classPrefix);
lock.lock();
try{
if(null != classes){
for(ClassTO tmp: classes) {
if(classKey.equals(tmp.getKey())) {
classTo=tmp;
break;
}
}
}else{
classes= new ArrayList();
classTo= new ClassTO(classKey);
}
methodTo = classTo.get(methodAndParamskey);
if(null == methodTo) {
methodTo=new MethodTO(methodAndParamskey);
}
}finally{
lock.unlock();
}
[/code]

亲，double-checked locking无外乎控制粒度再小一点点而已，这里已经是语句级别的同步方案，效率问题不会有太大影响的。再加上你这里分支太多了，暂时想不出来更好的解决方案，呵呵。。。 :oops: