欢迎您访问程序员文章站本站旨在为大家提供分享程序员计算机编程知识!
您现在的位置是: 首页  >  IT编程

一文说透如何同步的方式操作HashMap

程序员文章站 2022-03-19 16:09:55
写在前面很多人都知道HashMap是非线程安全的。比如下面这段代码,多运行几次,基本每次会抛出异常:final Map map = new HashMap<>(); long count = 0; final Integer targetKey = 0b1111_1111_1111_1111; // 65 535 final String targetValue = "v"; m...

写在前面

很多人都知道HashMap是非线程安全的。比如下面这段代码,多运行几次,基本每次会抛出异常:

final Map<Integer, String> map = new HashMap<>();
        long count = 0;

        final Integer targetKey = 0b1111_1111_1111_1111; // 65 535
        final String targetValue = "v";

        map.put(targetKey, targetValue);

        //range的范围是0~65534
        new Thread(() -> {
            IntStream.range(0, targetKey).forEach(key -> map.put(key, "someValue"));
        }).start();


        while (true) {
            if (!targetValue.equals(map.get(targetKey))) {
                System.out.println("跑了" + count + "次,抛出异常了");
                throw new RuntimeException("HashMap is not thread safe.");
            }
            count++;

        }

抛出异常就是HashMap的证明。上面的示例中,一个线程不断的put,另一个线程检查一开始设置的某个key的value是否有变化。正常情况下当然不会有变化。但是因为HashMap是非线程安全的,在put过程中会触发resize(扩容),而这个动作在多线程环境下容易形成死循环或者数据错乱。

使用 Collections.synchronizedMap同步

这是java.util.Collections提供的一个静态方法,用这个方法包装下HashMap,它就变成线程安全的了。示例:

final Map<Integer, String> map = new HashMap<>();
        long count = 0;

        // Synchronized HashMap
        Map<Integer, String> synchronizedMap
                = Collections.synchronizedMap(map);


        final Integer targetKey = 0b1111_1111_1111_1111; // 65 535
        final String targetValue = "v";

        synchronizedMap.put(targetKey, targetValue);

        //range的范围是0~65534
        new Thread(() -> {
            IntStream.range(0, targetKey).forEach(key -> synchronizedMap.put(key, "someValue"));
        }).start();


        while (true) {
            if (!targetValue.equals(synchronizedMap.get(targetKey))) {
                System.out.println("跑了" + count + "次,抛出异常了");
                throw new RuntimeException("HashMap is not thread safe.");
            }
            count++;

        }

这段代码无论你运行多少次都不会抛出异常了。

synchronizedMap实现线程安全的原理也很简单,它首先基于当前的map对象生成一个新的map类型synchronizedMap, 这是Collections类里面的一个内部类。

public static <K,V> Map<K,V> synchronizedMap(Map<K,V,> m) {
        return new SynchronizedMap<>(m);
    }

进入源码可以看到它的所有操作都用了synchronized加了一个对象锁,

public int size() {
            synchronized (mutex) {return m.size();}
        }
        public boolean isEmpty() {
            synchronized (mutex) {return m.isEmpty();}
        }
        public boolean containsKey(Object key) {
            synchronized (mutex) {return m.containsKey(key);}
        }
        public boolean containsValue(Object value) {
            synchronized (mutex) {return m.containsValue(value);}
        }
        public V get(Object key) {
            synchronized (mutex) {return m.get(key);}
        }

        public V put(K key, V value) {
            synchronized (mutex) {return m.put(key, value);}
        }
        public V remove(Object key) {
            synchronized (mutex) {return m.remove(key);}
        }
        public void putAll(Map<? extends K, ? extends V> map) {
            synchronized (mutex) {m.putAll(map);}
        }
        public void clear() {
            synchronized (mutex) {m.clear();}
        }

使用ConcurrentHashMap同步

还是上面那个示例:

final Map<Integer, String> synchronizedMap = new ConcurrentHashMap<>();
        long count = 0;

        final Integer targetKey = 0b1111_1111_1111_1111; // 65 535
        final String targetValue = "v";

        synchronizedMap.put(targetKey, targetValue);

        //range的范围是0~65534
        new Thread(() -> {
            IntStream.range(0, targetKey).forEach(key -> synchronizedMap.put(key, "someValue"));
        }).start();


        while (true) {
            if (!targetValue.equals(synchronizedMap.get(targetKey))) {
                System.out.println("跑了" + count + "次,抛出异常了");
                throw new RuntimeException("HashMap is not thread safe.");
            }
            count++;

        }

运行不抛出异常说明同步成功了。

一文说透如何同步的方式操作HashMap

在java7中,ConcurrentHashMap 是一个segment数组,segment通过继承 ReentrantLock来进行加锁,锁的颗粒度比较细,相当于每次锁住的是一个segment。这样性能更高。

java8的方式有些区别,是通过CAS实现的,这里不展开。

使用迭代器访问的情况需要关注下

synchronizedMap虽然是线程安全的map,但是它返回的迭代器(iterator)依然是HashMap的迭代器,而HashMap是fail-fast,并发修改的时候会报错。

看下面这个示例:

try {
            Map<String, String> hashMap = new HashMap<>();
            hashMap.put("1", "Hello");
            hashMap.put("2", "World");

            Map<String, String> synchronizedMap = Collections.synchronizedMap(hashMap);
            Iterator<String> it = synchronizedMap.keySet().iterator();
            while(it.hasNext()) {
                Object ele = it.next();
                System.out.println(synchronizedMap);
                if (ele.equals("1")) {
                    synchronizedMap.remove(ele);    //出错 修改了映射结构 影响了迭代器遍历
                }
            }

        } catch (Exception e) {
            // TODO: handle exception
            e.printStackTrace();
        }

会抛出ConcurrentModificationException异常。

如果使用ConcurrentHashMap则不同,因为它本身是对Map底层做了重新实现,针对并发访问进行了优化,可以认为在一定程度是“并发迭代器”。至于实现的原理我这里就不多说了,推荐一篇文章:

http://ifeve.com/java-concurrent-hashmap-1/

同步的HashMap也不是银弹

有些人会误以为使用了同步的HashMap就可以“为所欲为”了,其实在某些场景下ConcurrentHashMap也存在线程安全问题。下面是个示例:

public class TestHashMap {
    public static final int N = 5;
    public static final String KEY = "count";
    final Map<String, Integer> mapTest = new ConcurrentHashMap<String, Integer>();

    //初始化
    public TestHashMap() {
        mapTest.put(KEY, 0);
    }


    public static void main(String[] args) throws Exception{

        TestHashMap testHashMap = new TestHashMap();

        Thread thread1 = new Thread() {
            @Override
            public void run() {
                for(int j=0; j<100; j++){
                    testHashMap.add();
                }
            }
        };

        Thread thread2 = new Thread() {
            @Override
            public  void run() {
                for(int j=0; j<100; j++){
                    testHashMap.add();
                }
            }
        };


        thread1.start();
        thread2.start();
        thread1.join();
        thread2.join();

        //打印结果跟你想的是不是一样呢?
        testHashMap.printResult();
    }

    public void add() {
        mapTest.put(KEY, mapTest.get(KEY)+1);
    }

    public void printResult() {
        System.out.println(mapTest.get(KEY));

    }
}

这个其实想想是很容易理解的,这是一个先读后写测场景,写的数据依赖前面读的结果。所以我们应该要保证读-写这整个操作的原子性,而ConcurrentHashMap本身只是保证Map内部数据结构操作的原子性。

这个跟我们在数据库里操作一行数据很像,比如A、B两个线程操作1号账户的钱包(表里的一行记录),余额为1000元。A线程为该账户增加100元,B线程同时为该账户扣除50元,A先提交,B后提交。最后实际账户余额为1000-50=950元,但本该为1000+100-50=1050。

虽然数据库本身有行锁,但是我们操作的时候还是需要给上面的流程整体加锁(悲观锁,乐观锁都可以)

说了这么多,上面这个问题的解决方案也呼之欲出了,只需要在add方法加锁即可。

public synchronized void add() {
        mapTest.put(KEY, mapTest.get(KEY)+1);
    }

总结下synchronizedMap 和 ConcurrentHashMap的区别

首先,从上面分析的同步原理看,synchronizedMap加锁是基于操作的,简单粗暴。而ConcurrentHashMap是分段加锁,锁的颗粒度更细,性能自然更高。高并发的场景下还是建议使用后者。

还有一个区别是,ConcurrentHashMap永远不会抛出ConcurrentModificationException异常。而synchronizedMap在迭代遍历时,如果某些元素被删除了,会触发fail-fast机制抛出ConcurrentModificationException异常。

本文地址:https://blog.csdn.net/pony_maggie/article/details/110789664