Map 非线程安全的证明 以及线程安全方案（Concurrent）

参考 http://blog.csdn.net/nx188/article/details/50988037

一、概述
      大部分容器（比如：List、Map、Set）都是设计成非线程安全的，因为任何同步都是会损耗性能的。除了部分，如Vector是线程安全的。
线程安全的定义：
      比如一个 ArrayList 类，在添加一个元素的时候，它可能会有两步来完成：1. 在 Items[Size] 的位置存放此元素；2. 增大 Size 的值。
      在单线程运行的情况下，如果 Size = 0，添加一个元素后，此元素在位置 0，而且 Size=1；
      而如果是在多线程情况下，比如有两个线程，线程 A 先将元素1存放在位置 0。但是此时 CPU 调度线程A暂停，线程 B 得到运行的机会。线程B向此 ArrayList 添加元素2，因为此时 Size 仍然等于 0 （注意，我们假设的是添加一个元素是要两个步骤，而线程A仅仅完成了步骤1），所以线程B也将元素存放在位置0。然后线程A和线程B都继续运行，都增加 Size 的值，结果Size等于2。
      那好，我们来看看 ArrayList 的情况，期望的元素应该有2个，而实际只有一个元素，造成丢失元素，而且Size 等于 2。这就是“线程不安全”了。

二、代码验证
      验证方式通过累加，如果有定义中数据丢失的情况，那么累加出的结果就比正常值小。以map的5种同步方式来验证该业务流程下的线程安全方案。
（1）普通map
（2）synchronized修饰下的map操作集合
（3）ReentrantLock加锁的map操作集合
（4）ReentrantReadWriteLock加锁的map存取操作
（5）collections.synchronizedMap
（6）ConcurrentMap

package com.demo.test;

import java.util.ArrayList;
import java.util.Collections;
import java.util.HashMap;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ConcurrentMap;
import java.util.concurrent.locks.ReentrantLock;
import java.util.concurrent.locks.ReentrantReadWriteLock;

public class ThreadSafe {

    public static final String KEY = "key";
    public static final int THREAD_COUNT = 1000;
    private enum SynType {
        NONE, SYNCHRONIZED, REENTRANTLOCK, REENTRANTREADWRITELOCK, COLLECTIONS_SYNC
    }

    private static Map<String, Long> map = new HashMap<String, Long>();
    private static Map<String, Long> collectionsSyncMap = Collections.synchronizedMap(map);
    private static ConcurrentMap<String, Long> concurrentMap = new ConcurrentHashMap<String, Long>();

    private static ReentrantLock reentrantLock = new ReentrantLock();
    private static ReentrantReadWriteLock readWriteLock = new ReentrantReadWriteLock();

    public static long mapIncrease(String key) {
        Long oldValue = map.get(key);
        Long newValue = (oldValue == null) ? 1L : oldValue + 1;
        map.put(key, newValue);
        return newValue;
    }

    public synchronized static long synchronizedMapIncrease(String key) {
        Long oldValue = map.get(key);
        Long newValue = (oldValue == null) ? 1L : oldValue + 1;
        map.put(key, newValue);
        return newValue;
    }

    public static long reentrantLockMapIncrease(String key) {
        reentrantLock.lock();
        Long oldValue = map.get(key);
        Long newValue = (oldValue == null) ? 1L : oldValue + 1;
        map.put(key, newValue);
        reentrantLock.unlock();
        return newValue;
    }

    public static long readWriteLockMapIncrease(String key) {
        readWriteLock.readLock().lock();
        Long oldValue = map.get(key);
        Long newValue = (oldValue == null) ? 1L : oldValue + 1;
        readWriteLock.readLock().unlock();
        readWriteLock.writeLock().lock();
        map.put(key, newValue);
        readWriteLock.writeLock().unlock();
        return newValue;
    }

    public static long collectionsSyncMapIncrease(String key) {
        Long oldValue = collectionsSyncMap.get(key);
        Long newValue = (oldValue == null) ? 1L : oldValue + 1;
        collectionsSyncMap.put(key, newValue);
        return newValue;
    }

    public static long concurrentMapIncrease(String key) {
        Long oldValue, newValue;
        while (true) {
            oldValue = concurrentMap.get(key);
            if (oldValue == null) {
                newValue = 1L;
                if (concurrentMap.putIfAbsent(key, newValue) == null) {
                    break;
                }
            } else {
                newValue = oldValue + 1;
                if (concurrentMap.replace(key, oldValue, newValue)) {
                    break;
                }
            }
        }
        return newValue;
    }

    public static void calcMapCount(final SynType synType) throws InterruptedException {
        ArrayList<Thread> list = new ArrayList<Thread>(THREAD_COUNT);
        for (int i = 0; i < THREAD_COUNT; i++) {
            Thread thread = new Thread(new Runnable() {
                public void run() {
                    int count = 0;
                    while (count++ < 10000) {
                        switch (synType) {
                        case NONE:
                            mapIncrease(KEY);
                            break;
                        case SYNCHRONIZED:
                            synchronizedMapIncrease(KEY);
                            break;
                        case REENTRANTLOCK:
                            reentrantLockMapIncrease(KEY);
                            break;
                        case REENTRANTREADWRITELOCK:
                            readWriteLockMapIncrease(KEY);
                            break;
                        case COLLECTIONS_SYNC:
                            collectionsSyncMapIncrease(KEY);
                            break;
                        }
                    }
                }
            });
            thread.start();
            list.add(thread);
        }
        for (int i = 0; i < THREAD_COUNT; i++) {
            list.get(i).join();
        }
    }

    public static void calcConcurrentMapCount() throws InterruptedException {
        ArrayList<Thread> list = new ArrayList<Thread>(THREAD_COUNT);
        for (int i = 0; i < THREAD_COUNT; i++) {
            Thread thread = new Thread(new Runnable() {
                public void run() {
                    int count = 0;
                    while (count++ < 10000)
                        ThreadSafe.concurrentMapIncrease(KEY);
                }
            });
            thread.start();
            list.add(thread);
        }
        for (int i = 0; i < THREAD_COUNT; i++) {
            list.get(i).join();
        }
    }

    public static void main(String[] args) throws InterruptedException {
        for (int i = 0; i < 3; i++) {
            calcMapCount(SynType.NONE);
            System.out.println("map = " + map.get(KEY));
            map.clear();

            calcMapCount(SynType.SYNCHRONIZED);
            System.out.println("synchronized map = " + map.get(KEY));
            map.clear();

            calcMapCount(SynType.REENTRANTLOCK);
            System.out.println("reentrantLockMap = " + map.get(KEY));
            map.clear();

            calcMapCount(SynType.REENTRANTREADWRITELOCK);
            System.out.println("reentrantReadWriteLockMap = " + map.get(KEY));
            map.clear();

            calcMapCount(SynType.COLLECTIONS_SYNC);
            System.out.println("collections.synchronizedMap = " + collectionsSyncMap.get(KEY));
            collectionsSyncMap.clear();
            map.clear();

            calcConcurrentMapCount();
            System.out.println("concurrentMap = " + concurrentMap.get(KEY));
            concurrentMap.clear();
        }
    }
}

三、运行截图

四、说明
      这里可以看出Map是非线程安全的。但ReentrainReadWriteLock 和 Collections.synchronizedMap 都是为了确保线程安全而构造出来的类，之所以在这里得出的结果不正确是因为：同步的方式与具体的业务逻辑有关。
      ReentrainReadWriteLock用在高并发读，低并发写，并且读出的数据与写入的数据无关的情况。例如：云盘上的文件。
      Collections.synchronizedMap 的本质是在对Map的每一个操作之前都上一把锁，因此如果读、写操作无关联，则可以使用该方法。比如读写本地记事本。