并发容器ConcurrentHashMap与synchronized联合使用达到线程安全

最近做的项目中遇到一个问题：明明用了ConcurrentHashMap，可是始终线程不安全
除去项目中的业务逻辑，简化后的代码如下：

public class Test40 {  
    public static void main(String[] args) throws InterruptedException {  
        for (int i = 0; i < 10; i++) {  
            System.out.println(test());  
        }  
    }  
    private static int test() throws InterruptedException {  
        ConcurrentHashMap<String, Integer> map = new ConcurrentHashMap<String, Integer>();  
        ExecutorService pool = Executors.newCachedThreadPool();  
        for (int i = 0; i < 8; i++) {  
            pool.execute(new MyTask(map));  
        }  
        pool.shutdown();  
        pool.awaitTermination(1, TimeUnit.DAYS);  
        return map.get(MyTask.KEY);  
    }  
}  
class MyTask implements Runnable {  
    public static final String KEY = "key";  
    private ConcurrentHashMap<String, Integer> map;  
    public MyTask(ConcurrentHashMap<String, Integer> map) {  
        this.map = map;  
    }  
    @Override  
    public void run() {  
        for (int i = 0; i < 100; i++) {  
            this.addup();  
        }  
    }  
    private void addup() {  
        if (!map.containsKey(KEY)) {  
            map.put(KEY, 1);  
        } else {  
            map.put(KEY, map.get(KEY) + 1);  
        }      
    }  
}

测试代码跑了10次，每次都不是800。这就很让人疑惑了，难道ConcurrentHashMap的线程安全性失效了？
查了一些资料后发现，原来ConcurrentHashMap的线程安全指的是，它的每个方法单独调用（即原子操作）都是线程安全的，但是代码总体的互斥性并不受控制。以上面的代码为例，最后一行中的：

map.put(KEY, map.get(KEY) + 1);

实际上并不是原子操作，它包含了三步：

1. map.get
2. 加1
3. map.put

其中第1和第3步，单独来说都是线程安全的，由ConcurrentHashMap保证。但是由于在上面的代码中，map本身是一个共享变量。当线程A执行map.get的时候，其它线程可能正在执行map.put，这样一来当线程A执行到map.put的时候，线程A的值就已经是脏数据了，然后脏数据覆盖了真值，导致线程不安全
简单地说，ConcurrentHashMap的get方法获取到的是此时的真值，但它并不保证当你调用put方法的时候，当时获取到的值仍然是真值
为了使上面的代码变得线程安全，我引入了synchronized关键字来修饰目标方法，如下：

public class Test40 {  
    public static void main(String[] args) throws InterruptedException {  
        for (int i = 0; i < 100; i++) {  
            System.out.println(test());  
        }  
    }  
    private static int test() throws InterruptedException {  
        Map<String, Integer> map = new HashMap<String, Integer>();  
        ExecutorService pool = Executors.newCachedThreadPool();  
        for (int i = 0; i < 8; i++) {  
            pool.execute(new MyTask(map));  
        }  
        pool.shutdown();  
        pool.awaitTermination(1, TimeUnit.DAYS);  
        return map.get(MyTask.KEY);  
    }  
}  
class MyTask implements Runnable {  
    public static Object lock = new Object();  
    public static final String KEY = "key";  
    private Map<String, Integer> map;  
    public MyTask(Map<String, Integer> map) {  
        this.map = map;  
    }  
    @Override  
    public void run() {  
        for (int i = 0; i < 100; i++) {  
            synchronized (lock) {  
                this.addup();  
            }  
        }  
    }  
    private void addup() {  
        if (!map.containsKey(KEY)) {  
            map.put(KEY, 1);  
        } else {  
            map.put(KEY, map.get(KEY) + 1);  
        }  
    }  
}

然而此时使用ConcurrentHashMap已经没什么意义了