【集合】SynchronizedMap 源码分析

- 日理万妓 2022-10-18 01:36 173阅读 0赞

# 前言 #

Github：[https://github.com/yihonglei/jdk-source-code-reading][https_github.com_yihonglei_jdk-source-code-reading]

[HashTable 源码][HashTable]

[HashMap 源码][HashMap]

[ConcurrentHashMap 源码][ConcurrentHashMap]

# 一 概述 #

SynchronizedMap 通过 synchronized 加锁实现线程安全，锁整个 hash 表，性能跟 HashTable

差不多，不同的是 SynchronizedMap 支持选择锁定对象和 Map 的底层实现，实际应用中很少用

到，实际中 常用的是非线程安全 HashMap，高并发线程安全 ConcurrentHashMap。

# 二 实例 #

package com.jpeony.collection.hash;
    
    import java.util.Collections;
    import java.util.HashMap;
    import java.util.Map;
    
    /**
     * @author yihonglei
     */
    public class SynchronizedMapTest {
        public static void main(String[] args) {
            Map<String, String> synchronizedMap = Collections.synchronizedMap(new HashMap<>(16));
            synchronizedMap.put("key1", "sync1");
            synchronizedMap.put("key2", "sync2");
            synchronizedMap.put("key3", "sync3");
            for (String key : synchronizedMap.keySet()) {
                System.out.println("key= " + key + " and value = " + synchronizedMap.get(key));
            }
        }
    }

# 三 SynchronizedMap 底层实现 #

**重点分析 put() 和 get() 方法。**

## 类结构 ##

java.util.Collections 集合类的静态内部类。

private static class SynchronizedMap<K,V>
        implements Map<K,V>, Serializable {
        private static final long serialVersionUID = 1978198479659022715L;
    
        // Map 实现类，比如 HashMap，作为 SynchronizedMap 底层存储结构
        private final Map<K,V> m;     // Backing Map
        // synchronized 同步锁的加锁对象，可以自定义锁定对象，默认用本类作为锁对象
        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;
        }
        // ......
    }

## java.util.Collections.SynchronizedMap\#put() ##

public V put(K key, V value) {
        // synchronized 对象锁，线程只能串行访问，保证线程安全
        synchronized (mutex) {return m.put(key, value);}
    }

m.put(key, value) 逻辑取决于构建的基础 Map 的底层实现。

## java.util.Collections.SynchronizedMap\#get() ##

public V get(Object key) {
        // synchronized 对象锁，线程只能串行访问，保证线程安全
        synchronized (mutex) {return m.get(key);}
    }

m.get(key, value) 逻辑取决于构建的基础 Map 的底层实现。

# 四 总结 #

1、SynchronizedMap 和 HashTable 都是通过 synchronized 同步锁保证线程安全的，

二者性能差不多，并发性能极低，SynchronizedMap 支持选择锁定的对象 和 构建基础 Map，

称为有条件的线程安全散列表；

2、jdk2 的时候出现的SynchronizedMap，一般构建 HashMap 基础结构，因为 HashMap

是非线程安全的，通过 SynchronizedMap 保证线程安全，可以多用些 HashTable 不具有

的特性，比如， HashMap 允许 key 或 value 都为空，底层的查找速度优于 HashTable，

因为在 jdk8引入了红黑树优化链表，而不会像 HashTable 一样，极端情况下所有数据会

退化到一个链表，导致查询时间复杂度从 O(1) 上升为 O(n)；

3、估计是官方自己也觉得 SynchronizedMap 保证 HashMap 保证线程安全，只是在某些方面

提高了性能，但是并发度并没有多大提升，所以在 jdk5 的时候开发了 ConcurrentHashMap，

来解决高并发和线程安全问题，在 jdk7 以前，使用分段锁保证线程池安全，给每个桶加锁，

但是 锁粒度太大，并发达不到极致，并且冲突解决还是依赖链表，可能会出现查询退化到 O(n)，

所以在 jdk8 的时候，引入了红黑树优化链表退化，并且通过 cas 加锁，把锁的粒度细化到链表

的节点，而不是整个桶加锁，极大的提高了查询性能和容器的并发度，更好的支持线程安全的

高并发容器集合。

[https_github.com_yihonglei_jdk-source-code-reading]: https://github.com/yihonglei/jdk-source-code-reading
[HashTable]: https://jpeony.blog.csdn.net/article/details/109698072
[HashMap]: https://jpeony.blog.csdn.net/article/details/110446413
[ConcurrentHashMap]: https://jpeony.blog.csdn.net/article/details/110677912