Map接口实现类ConcurrentHashMap源码及详解

最新推荐文章于 2024-05-21 23:43:50 发布

jianning-wu

最新推荐文章于 2024-05-21 23:43:50 发布

阅读量2.8k

点赞数 8

分类专栏： Java 容器文章标签： synchronizedMap hashmap ConcurrentMap 线程安全线程安全的Map

本文链接：https://blog.csdn.net/weixin_37730482/article/details/69281691

版权

Java 容器专栏收录该内容

12 篇文章 0 订阅

订阅专栏

上一章节讲述了HashMap源码及详解

https://blog.csdn.net/weixin_37730482/article/details/73826216

可知，HashMap不是线程安全的。那么要实现线程安全的Map怎样实现呢？有三种常用的实现方法

<1> Hashtable实现

https://blog.csdn.net/weixin_37730482/article/details/71191231

<2> SynchronizeMap(Collections.synchronizeMap方法返回的对象)实现

<3> ConcurrentHashMap实现

一.SynchronizeMap(Collections.synchronizeMap方法返回的对象)实现线程安全的Map

1.demo

public class CollectionActivity extends AppCompatActivity {

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_collection);

        initArrayList();
    }

    public void initArrayList() {

        HashMap<String, String> hashMap = new HashMap<String, String>();
        hashMap.put("1", "张三");
        hashMap.put("2", "李四");
        hashMap.put("3", "王五");
        hashMap.put("4", "赵六");
        hashMap.put("5", "980");

        Set<Map.Entry<String, String>> entrySet = hashMap.entrySet();
        Iterator<Map.Entry<String, String>> iterator = entrySet.iterator();
        while (iterator.hasNext()) {
            Map.Entry<String, String> map = iterator.next();
            String key = map.getKey();
            String value = map.getValue();
            Log.i("CollectionActivity", "原始key----" + key + "----原始value----:" + value);
        }

        Map<String, String> map = Collections.synchronizedMap(hashMap);
        Set<Map.Entry<String, String>> mapEntrySet = map.entrySet();
        Iterator<Map.Entry<String, String>> mapIterator = mapEntrySet.iterator();
        while (mapIterator.hasNext()) {
            Map.Entry<String, String> entry = mapIterator.next();
            String key = entry.getKey();
            String value = entry.getValue();
            Log.i("CollectionActivity", "操作后key----" + key + "----操作后value----:" + value);
        }

    }

}

2.结果

I/CollectionActivity: 原始key----1----原始value----:张三

I/CollectionActivity: 原始key----2----原始value----:李四

I/CollectionActivity: 原始key----3----原始value----:王五

I/CollectionActivity: 原始key----4----原始value----:赵六

I/CollectionActivity: 原始key----5----原始value----:980




I/CollectionActivity: 操作后key----1----操作后value----:张三

I/CollectionActivity: 操作后key----2----操作后value----:李四

I/CollectionActivity: 操作后key----3----操作后value----:王五

I/CollectionActivity: 操作后key----4----操作后value----:赵六

I/CollectionActivity: 操作后key----5----操作后value----:980

3.源码分析

demo可以看出，使用下面一行代码

Collections.synchronizedMap(hashMap);

即，使用Collections类的synchronizedMap方法，将一个HashMap(线程不安全)变成一个线程安全的Map。那么他怎么实现的呢？

因为这个方法返回SynchronizedMap对象。那么我们看一下这个类的源码

SynchronizedMap类部分源码

/**
 * @serial include
 */
private static class SynchronizedMap<K,V>implements Map<K,V>, Serializable {
    private static final long serialVersionUID = 1978198479659022715L;

    private final Map<K,V> m;     // Backing Map
    final Object      mutex;        // Object on which to synchronize

    SynchronizedMap(Map<K,V> m) {
        this.m = Objects.requireNonNull(m);
        mutex = this;
    }

    SynchronizedMap(Map<K,V> m, Object mutex) {
        this.m = m;
        this.mutex = mutex;
    }

    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();}
    }

      
    private transient Set<K> keySet;
        
    private transient Set<Map.Entry<K,V>> entrySet;
        
    private transient Collection<V> values;

    public Set<K> keySet() {
        synchronized (mutex) {
            if (keySet==null)
                keySet = new SynchronizedSet<>(m.keySet(), mutex);
            return keySet;
        }
    }

    public Set<Map.Entry<K,V>> entrySet() {
        synchronized (mutex) {
            if (entrySet==null)
                entrySet = new SynchronizedSet<>(m.entrySet(), mutex);
            return entrySet;
        }
    }

    public Collection<V> values() {
        synchronized (mutex) {
             if (values==null)
                values = new SynchronizedCollection<>(m.values(), mutex);
            return values;
        }
    }

}

也就是说，Collections.synchronizedMap()方法，返回的SynchronizedMap实现线程安全的方式和HashTable一样。即所有方法都加了同步锁。

二.ConcurrentHashMap的简单使用

因为ConcurrentHashMap是基于HashMap改造的。所以ConcurrentHashMap在使用上，和HashMap大致一样。这里举几个常用的方法。

1.添加元素

ConcurrentHashMap<String, String> concurrentHashMap = new ConcurrentHashMap<>();
concurrentHashMap.put("1", "张三");

2.删除元素

ConcurrentHashMap<String, String> concurrentHashMap = new ConcurrentHashMap<>();
concurrentHashMap.remove("1");

3.获取元素

ConcurrentHashMap<String, String> concurrentHashMap = new ConcurrentHashMap<>();
concurrentHashMap.get("1");

4.遍历获取Key

public class CollectionActivity extends AppCompatActivity {

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_collection);

        initArrayList();
    }

    public void initArrayList() {

        ConcurrentHashMap<String, String> concurrentHashMap = new ConcurrentHashMap<>();
        concurrentHashMap.put("1", "张三");
        concurrentHashMap.put("2", "李四");
        concurrentHashMap.put("3", "王五");
        concurrentHashMap.put("4", "赵六");
        concurrentHashMap.put("5", "980");

        Set<String> set = concurrentHashMap.keySet();
        Iterator<String> iterator = set.iterator();
        while (iterator.hasNext()) {
            String key = iterator.next();
            String value = concurrentHashMap.get(key);
            Log.d("CollectionActivity", "key----：" + key + "----value：" + value);
        }

    }

}

D/CollectionActivity: key----：1----value：张三


D/CollectionActivity: key----：2----value：李四


D/CollectionActivity: key----：3----value：王五


D/CollectionActivity: key----：4----value：赵六


D/CollectionActivity: key----：5----value：980

5.遍历获取Value

public class CollectionActivity extends AppCompatActivity {

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_collection);

        initArrayList();
    }

    public void initArrayList() {

        ConcurrentHashMap<String, String> concurrentHashMap = new ConcurrentHashMap<>();
        concurrentHashMap.put("1", "张三");
        concurrentHashMap.put("2", "李四");
        concurrentHashMap.put("3", "王五");
        concurrentHashMap.put("4", "赵六");
        concurrentHashMap.put("5", "980");

        Collection<String> collection = concurrentHashMap.values();
        Iterator<String> iterator = collection.iterator();
        while (iterator.hasNext()) {
            String value = iterator.next();
            Log.d("CollectionActivity", "value：" + value);
        }

    }

}

D/CollectionActivity: value：张三


D/CollectionActivity: value：李四


D/CollectionActivity: value：王五


D/CollectionActivity: value：赵六


D/CollectionActivity: value：980

6.遍历获取Key-Value

public class CollectionActivity extends AppCompatActivity {

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_collection);

        initArrayList();
    }

    public void initArrayList() {

        ConcurrentHashMap<String, String> concurrentHashMap = new ConcurrentHashMap<>();
        concurrentHashMap.put("1", "张三");
        concurrentHashMap.put("2", "李四");
        concurrentHashMap.put("3", "王五");
        concurrentHashMap.put("4", "赵六");
        concurrentHashMap.put("5", "980");

        Set<Map.Entry<String, String>> set = concurrentHashMap.entrySet();
        Iterator<Map.Entry<String, String>> iterator = set.iterator();
        while (iterator.hasNext()) {
            Map.Entry<String, String> entry = iterator.next();
            String key = entry.getKey();
            String value = entry.getValue();
            Log.d("CollectionActivity", "key----：" + key + "----value：" + value);
        }

    }

}

D/CollectionActivity: key----：1----value：张三


D/CollectionActivity: key----：2----value：李四


D/CollectionActivity: key----：3----value：王五


D/CollectionActivity: key----：4----value：赵六


D/CollectionActivity: key----：5----value：980

三.源码分析

源码分析之添加元素

使用

ConcurrentHashMap<String, String> concurrentHashMap = new ConcurrentHashMap<>();
concurrentHashMap.put("1", "张三");

源码

/**
 * Maps the specified key to the specified value in this table.
 * Neither the key nor the value can be null.
 *
 * <p>The value can be retrieved by calling the {@code get} method
 * with a key that is equal to the original key.
 *
 * @param key key with which the specified value is to be associated
 * @param value value to be associated with the specified key
 * @return the previous value associated with {@code key}, or
 *         {@code null} if there was no mapping for {@code key}
 * @throws NullPointerException if the specified key or value is null
 */
 public V put(K key, V value) {
    return putVal(key, value, false);
 }

/** Implementation for put and putIfAbsent */
final V putVal(K key, V value, boolean onlyIfAbsent) {
    //如果Key或者Value为空，则抛出异常
    if (key == null || value == null) throw new NullPointerException();
    
    //计算hash值
    int hash = spread(key.hashCode());


    //链表的节点数
    int binCount = 0;

    
    for (Node<K,V>[] tab = table;;) {
        Node<K,V> f; int n, i, fh;

        //如果数组为空则进行初始化
        if (tab == null || (n = tab.length) == 0)
            tab = initTable();
        else if ((f = tabAt(tab, i = (n - 1) & hash)) == null) {
            //数组中对应下标对象为null
            if (casTabAt(tab, i, null,new Node<K,V>(hash, key, value, null)))
                break;// no lock when adding to empty bin
            }

        //数组正在扩容，帮忙迁移数据到新的数组
        else if ((fh = f.hash) == MOVED)
            tab = helpTransfer(tab, f);
        else {

            //普通的情况 注意这里同步对象是Node对象
            V oldVal = null;
            synchronized (f) {
                if (tabAt(tab, i) == f) {
                    if (fh >= 0) {
                        binCount = 1;
                        for (Node<K,V> e = f;; ++binCount) {
                            K ek;
                            if (e.hash == hash &&((ek = e.key) == key ||(ek != null && key.equals(ek)))) {
                                oldVal = e.val;
                                if (!onlyIfAbsent)
                                    e.val = value;
                                break;
                            }
                            Node<K,V> pred = e;
                            if ((e = e.next) == null) {pred.next = new Node<K,V>(hash, key,value, null);
                                break;
                            }
                        }
                    }
                    else if (f instanceof TreeBin) {
                        Node<K,V> p;
                        binCount = 2;
                        if ((p = ((TreeBin<K,V>)f).putTreeVal(hash, key,value)) != null) {
                            oldVal = p.val;
                            if (!onlyIfAbsent)
                                p.val = value;
                        }
                    }
                    else if (f instanceof ReservationNode)
                        throw new IllegalStateException("Recursive update");
                }
            }
            if (binCount != 0) {
                if (binCount >= TREEIFY_THRESHOLD)
                    treeifyBin(tab, i);
                if (oldVal != null)
                    return oldVal;
                break;
            }
        }
    }
    addCount(1L, binCount);
    return null;
}

小结1

<1> ConcurrentHashMap不允许空值，或者空键。

<2> ConcurrentHashMap获取hash值的方式和HashMap不同。具体下面讲解

<3> ConcurrentHashMap采用CAS进行插入方式。具体下面讲解

<4> ConcurrentHashMap同步的对象是Node即节点。具体下面讲解

源码分析之获取元素

使用

ConcurrentHashMap<String, String> concurrentHashMap = new ConcurrentHashMap<>();
concurrentHashMap.get("1");

源码

/**
 * Returns the value to which the specified key is mapped,
 * or {@code null} if this map contains no mapping for the key.
 *
 * <p>More formally, if this map contains a mapping from a key
 * {@code k} to a value {@code v} such that {@code key.equals(k)},
 * then this method returns {@code v}; otherwise it returns
 * {@code null}.  (There can be at most one such mapping.)
 *
 * @throws NullPointerException if the specified key is null
 */
public V get(Object key) {
    Node<K,V>[] tab; Node<K,V> e, p; int n, eh; K ek;
    int h = spread(key.hashCode());
    if ((tab = table) != null && (n = tab.length) > 0 &&(e = tabAt(tab, (n - 1) & h)) != null) {
        if ((eh = e.hash) == h) {
            if ((ek = e.key) == key || (ek != null && key.equals(ek)))
                return e.val;
        }
        else if (eh < 0)
            return (p = e.find(h, key)) != null ? p.val : null;
        while ((e = e.next) != null) {
            if (e.hash == h &&((ek = e.key) == key || (ek != null && key.equals(ek))))
                return e.val;
        }
    }
    return null;
}

源码分析之获取hash值

int hash = spread(key.hashCode());

static final int spread(int h) {
    return (h ^ (h >>> 16)) & HASH_BITS;
}

高低位异或扰动获取hash值。

源码分析之CAS

乐观锁&悲观锁

乐观锁和悲观锁并不是一种真实存在的锁，而是一种设计思想，乐观锁和悲观锁对于理解 Java 多线程来说至关重要。

悲观锁是一种悲观思想，它总认为最坏的情况可能会出现，它认为数据很可能会被其他人所修改，所以悲观锁在持有数据的时候总会把资源或者数据锁住，这样其他线程想要请求这个资源的时候就会阻塞，直到等到悲观锁把资源释放为止。Java 中的 Synchronized 和 ReentrantLock 等独占锁(排他锁)也是一种悲观锁思想的实现。

乐观锁的思想与悲观锁的思想相反，它总认为资源和数据不会被别人所修改，所以读取不会上锁，但是乐观锁在进行写入操作的时候会判断当前数据是否被修改过。乐观锁的实现方案一般来说有两种：版本号机制和 CAS实现。乐观锁多适用于多度的应用类型，这样可以提高吞吐量。在Java中java.util.concurrent.atomic包下面的原子变量类就是使用了乐观锁的一种实现方式CAS实现的。

CAS实现

CAS的全称是Compare And Swap 即比较交换。其算法核心思想

compareAndSwapObject(Object o, Object expected, Object x);

o表示要更新的变量

expected表示预期值

x表示新值

由于CAS操作属于乐观派，它总认为自己可以成功完成操作，当多个线程同时使用CAS操作一个变量时，只有一个会胜出，并成功更新，其余均会失败，但失败的线程并不会被挂起，仅是被告知失败，并且允许再次尝试，当然也允许失败的线程放弃操作，CAS操作即使没有锁，同样知道其他线程对共享资源操作影响，并执行相应的处理措施。同时从这点也可以看出，由于无锁操作中没有锁的存在，因此不可能出现死锁的情况，也就是说无锁操作天生免疫死锁。

或许你有这样的疑问，假设存在多个线程执行CAS操作并且CAS的步骤很多，有没有可能在判断expected和x相同后，正要赋值时，切换了线程，更改了值。造成了数据不一致呢？答案是否定的，因为CAS是一种系统原语，原语属于操作系统用语范畴，是由若干条指令组成的，用于完成某个功能的一个过程，并且原语的执行必须是连续的，在执行过程中不允许被中断。所以不会造成所谓的数据不一致问题。

四.总结

Hashtable与SynchronizeMap采取的并发策略是对整个数组对象加锁，导致性能及其低下。jdk1.7之前，ConcurrentHashMap采用的是锁分段策略来优化性能。jdk1.8之后，对整个策略进行了重构。锁的不是segment，而是节点。

 Node<K,V> f

synchronized (f) {


}

也就是说jdk1.8之后，锁的粒度进一步被降低，并发的效率也提高了。jdk1.8做得优化不只是细化锁粒度，还带来了CAS+synchronize的设计。

jianning-wu

关注

8
点赞
踩
13

收藏

觉得还不错? 一键收藏
0
评论
Map接口实现类ConcurrentHashMap源码及详解

1. 栈(stack)与堆(heap)都是Java用来在Ram中存放数据的地方。与C++不同，Java自动管理栈和堆，程序员不能直接地设置栈或堆。2. 栈的优势是，存取速度比堆要快，仅次于直接位于CPU中的寄存器。但缺点是，存在栈中的数据大小与生存期必须是确定的，缺乏灵活性。另外，栈数据在多个线程或者多个栈之间是不可以共享的，但是在栈内部多个值相等的变量是可以指
复制链接

扫一扫