ConcurrentHashMap介绍以及如何使用

最新推荐文章于 2025-05-31 18:50:39 发布

老张的Android之旅

最新推荐文章于 2025-05-31 18:50:39 发布

阅读量2k

点赞数 3

分类专栏： Android--经典案例文章标签： Android exception 线程-遍历

本文链接：https://blog.youkuaiyun.com/Zadarrien_China/article/details/51902878

版权

Android--经典案例专栏收录该内容

43 篇文章

订阅专栏

一、报错

Fatal Exception: java.util.ConcurrentModificationException
 Raw Text
java.util.HashMap$HashIterator.nextEntry (HashMap.java:787)
java.util.HashMap$ValueIterator.next (HashMap.java:819)
it.cast.zhang.logic.appmanager.AppManager.pushAppFlow (AppManager.java:920)
it.cast.zhang.logic.appmanager.AppManager.run (AppManagerImpl.ava:1011)
java.lang.Thread.run (Thread.java:818)

很明显上面这是并发修改异常的问题，我查了一下代码，发现那里只是做了一些增强for循环的一个操作，但里面并没有对其进行增删改查，后来发现这是多线程并发的问题，可能存在多个线程对其进行操作导致多线程并发修改异常。

二、为什么用这个东西？

多线程环境下，使用Hashmap进行put操作会引起死循环，导致CPU利用率接近100%，所以在并发情况下不能使用HashMap。虽然已经有一个线程安全的HashTable，但是HashTable容器使用synchronized（他的get和put方法的实现代码如下）来保证线程安全，在线程竞争激烈的情况下HashTable的效率非常低下。因为当一个线程访问HashTable的同步方法时，访问其他同步方法的线程就可能会进入阻塞或者轮训状态。如线程1使用put进行添加元素，线程2不但不能使用put方法添加元素，并且也不能使用get方法来获取元素，所以竞争越激烈效率越低

三、ConcurrentHashMap详解

ConcurrentHashMap的简要总结：

1、public V get(Object key)不涉及到锁，也就是说获得对象时没有使用锁；

2、put、remove方法要使用锁，但并不一定有锁争用，原因在于ConcurrentHashMap将缓存的变量分到多个Segment，每个Segment上有一个锁，只要多个线程访问的不是一个Segment就没有锁争用，就没有堵塞，各线程用各自的锁，ConcurrentHashMap缺省情况下生成16个Segment，也就是允许16个线程并发的更新而尽量没有锁争用；

3、Iterator对象的使用，不一定是和其它更新线程同步，获得的对象可能是更新前的对象，ConcurrentHashMap允许一边更新、一边遍历，也就是说在Iterator对象遍历的时候，ConcurrentHashMap也可以进行remove,put操作，且遍历的数据会随着remove,put操作产出变化，所以希望遍历到当前全部数据的话，要么以ConcurrentHashMap变量为锁进行同步(synchronized该变量)，要么使用CopiedIterator包装iterator，使其拷贝当前集合的全部数据，但是这样生成的iterator不可以进行remove操作。

Hashtable和ConcurrentHashMap的不同点：

1、Hashtable对get,put,remove都使用了同步操作，它的同步级别是正对Hashtable来进行同步的，也就是说如果有线程正在遍历集合，其他的线程就暂时不能使用该集合了，这样无疑就很容易对性能和吞吐量造成影响，从而形成单点。而ConcurrentHashMap则不同，它只对put,remove操作使用了同步操作，get操作并不影响，详情请看以上第1,2点，当前ConcurrentHashMap这样的做法对一些线程要求很严格的程序来说，还是有所欠缺的，对应这样的程序来说，如果不考虑性能和吞吐量问题的话，个人觉得使用Hashtable还是比较合适的；

2、Hashtable在使用iterator遍历的时候，如果其他线程，包括本线程对Hashtable进行了put，remove等更新操作的话，就会抛出ConcurrentModificationException异常，但如果使用ConcurrentHashMap的话，就不用考虑这方面的问题了

四、实战

HashMap或者ArrayList边遍历边删除数据会报异常java.util.ConcurrentModificationException

Map<Long, String> mReqPacket = new HashMap<Long, String>();
    for (long i = 0; i < 15; i++) {
        mReqPacket.put(i, i + "");
    }

    for (Entry<Long, String> entry : mReqPacket.entrySet()) {
        long key = entry.getKey();
        String value = entry.getValue();
        if (key < 10) {
            mReqPacket.remove(key);
        }
    }

    for (Entry<Long, String> entry : mReqPacket.entrySet()) {
        System.out.println(entry.getKey() + " " + entry.getValue());
    }

解决办法：所以要用迭代器删除元素：

     Map<Long, String> mReqPacket = new HashMap<Long, String>();
            for (long i = 0; i < 15; i++) {
                mReqPacket.put(i, i + "");
            }

            for (Iterator<Entry<Long, String>> iterator = mReqPacket.entrySet().iterator(); iterator.hasNext();) {
                Entry<Long, String> entry = iterator.next();
                long key = entry.getKey();
                if (key < 10) {
                    iterator.remove();
                }
            }

            for (Entry<Long, String> entry : mReqPacket.entrySet()) {
                System.out.println(entry.getKey() + " " + entry.getValue());

2.=对ConcurrentHashMap边遍历边删除或者增加操作不会产生异常(可以不用迭代方式删除元素)，因为其内部已经做了维护，遍历的时候都能获得最新的值。即便是多个线程一起删除、添加元素也没问题。

  Map<Long, String> conMap = new ConcurrentHashMap<Long, String>();
        for (long i = 0; i < 15; i++) {
            conMap.put(i, i + "");
        }

        for (Entry<Long, String> entry : conMap.entrySet()) {
            long key = entry.getKey();
            if (key < 10) {
                conMap.remove(key);
            }
        }

        for (Entry<Long, String> entry : conMap.entrySet()) {
            System.out.println(entry.getKey() + " " + entry.getValue());
        }

3.一个线程对ConcurrentHashMap增加数据，另外一个线程在遍历时就能获得。

static Map<Long, String> conMap = new ConcurrentHashMap<Long, String>();

    public static void main(String[] args) throws InterruptedException {
        for (long i = 0; i < 5; i++) {
            conMap.put(i, i + "");
        }

        Thread thread = new Thread(new Runnable() {
            public void run() {
                conMap.put(100l, "100");
                System.out.println("ADD:" + 100);
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }

        });
        Thread thread2 = new Thread(new Runnable() {
            public void run() {
                for (Iterator<Entry<Long, String>> iterator = conMap.entrySet().iterator(); iterator.hasNext();) {
                    Entry<Long, String> entry = iterator.next();
                    System.out.println(entry.getKey() + " - " + entry.getValue());
                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        });
        thread.start();
        thread2.start();

        Thread.sleep(3000);
        System.out.println("--------");
        for (Entry<Long, String> entry : conMap.entrySet()) {
            System.out.println(entry.getKey() + " " + entry.getValue());
        }

    }

输出：
ADD:100
0 - 0
100 - 100
2 - 2
1 - 1
3 - 3
4 - 4
--------
0 0
100 100
2 2
1 1
3 3
4 4