Bootstrap

线程安全的HashTable、ConcurrentHashMap和SynchronizedMap

面试官：HashMap是线程安全的吗？

你：不是线程安全的，因为……（balabala）

面试官：很好，那既然是线程不安全的话，有什么可以替代他的呢？

你：HashTable、ConcurrentHashMap、和SynchronizedMap

面试官：你能讲一下他们具体的底层原理，为什么是线程安全的吗？

你：……

面试官：好的，那我们今天的面试就到这里，回家等联系吧

文章目录

1、讲一下HashTable为什么是线程安全的？

public class Hashtable<K,V>
    extends Dictionary<K,V>
    implements Map<K,V>, Cloneable, java.io.Serializable {
    	//...
    	public synchronized boolean isEmpty() {
        	return count == 0;
    	}
    	//...
    }

从上面我们可以看到，HashTable之所以是线程安全的，是因为在每个方法的前面都加了
Synchronized关键字，将整个方法锁起来了，所以是线程安全的

但是安全归安全，效率太地下了啊，如果我要添加一个元素，你把我整个表锁起来了，那
我还玩个毛啊。如果我有2000个并发进来，一个并发操作1s，那要等待半个多小时，怕是
会被人骂死。

2、讲一下SynchronizedMap为什么是线程安全的？

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

	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);}
        }
        //...
     }
}

首先Collections.SynchronizedMap是实现Map<K,V>接口的，不是继承自AbstractMap<K,V>抽象类的

我们再来看一下它的构造函数，有两个参数，第一个是HashMap，第二个是Object
第二个Object对象是用来做互斥锁的，如果第二个没传入的话，我们默认是使用HashMap
对象

为什么是线程安全的，你看一下源代码就知道了，每一个方法里面都有一个同步代码块，
锁头正是传入的对象或hashMap本身

3、讲一下ConcurrentHashMap为什么是线程安全的？

jdk1.8

public class ConcurrentHashMap<K,V> extends AbstractMap<K,V>
    implements ConcurrentMap<K,V>, Serializable {
    
    }

在这里插入图片描述

ConcurrentHashMap和HashMap一样，再jdk1.7和jdk1.8有一点不同
------------------------jdk1.7------------------------
jdk1.7中，和HashMap一样，也是使用数组+链表
使用了segment分段锁的概念，Segment继承自ReentrantLock

static final class Segment<K,V> 
		extends ReentrantLock 
		implements Serializable {

    private static final long serialVersionUID 
    					= 2249069246763182397L;

    // 和 HashMap 中的 HashEntry 作用一样，真正存放数据的桶
    transient volatile HashEntry<K,V>[] table;

    transient int count;
        // 记得快速失败（fail—fast）么？
    transient int modCount;
        // 大小
    transient int threshold;
        // 负载因子
    final float loadFactor;

}

HashEntry跟HashMap差不多的，但是不同点是， 他使用volatile去修饰了他的数据Value还有下一个节点next。

volatile的特性？

  • 保证了不同线程对这个变量进行操作时的可见性，即一个线程修改了某个变量的值，这新值对其他线程来说是立即可见的。（实现可见性）
  • 禁止进行指令重排序。（实现有序性）
  • volatile 只能保证对单次读/写的原子性。i++ 这种操作不能保证原子性。

------------------------jdk1.8------------------------
jdk1.8以后，抛弃了segment分段锁，采用cas+synchronized保证安全性

在这里插入图片描述
jdk1.8我们来看一下put的源码：

	static final int HASH_BITS = 0x7fffffff; // usable bits of normal node hash
	
	static final int spread(int h) {
        return (h ^ (h >>> 16)) & HASH_BITS;
    }
	
	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) {
        if (key == null || value == null) throw new NullPointerException();
        //1、对键进行hash运算，高16位和低16位异或，再和0x7fffffff相与
        int hash = spread(key.hashCode());
        int binCount = 0;
        //2、定位Node
        for (Node<K,V>[] tab = table;;) {
            Node<K,V> f; int n, i, fh;
            if (tab == null || (n = tab.length) == 0)
                tab = initTable();//3、如果不存在，创建一个
            else if ((f = tabAt(tab, i = (n - 1) & hash)) == 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 {
                V oldVal = null;
                //3、上锁
                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;
                            }
                        }
                    }
                }
                if (binCount != 0) {
                    if (binCount >= TREEIFY_THRESHOLD)
                        treeifyBin(tab, i);
                    if (oldVal != null)
                        return oldVal;
                    break;
                }
            }
        }
        addCount(1L, binCount);
        return null;
    }

get源码：

/**
     * 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;
    }

总结： -------------------put-------------------
1、根据 key 计算出 hashcode
2、判断是否需要进行初始化。
3、即为当前 key 定位出的 Node，如果为空表示当前位置可以写入数据，利用 CAS 尝试写入，失败则自旋保证成功。
4、如果当前位置的 hashcode == MOVED == -1,则需要进行扩容。
5、如果都不满足，则利用 synchronized 锁写入数据。
6、如果数量大于 TREEIFY_THRESHOLD则要转换为红黑树。
-------------------get-------------------
通过观察源码，我们可以看到，get的过程整个都没有上锁
1、根据计算出来的 hashcode 寻址，如果就在桶上那么直接返回值。
2、如果是红黑树那就按照树的方式获取值。
3、就不满足那就按照链表的方式遍历获取值。

4、HashTable和HashMap的区别

首先我们回顾一个HashMap 的定义

public class HashMap<K,V> extends AbstractMap<K,V>
    implements Map<K,V>, Cloneable, Serializable {
    //……
	    static final int hash(Object key) {
	        int h;
	        return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
	    }
    }

再回顾一下HashTable 的定义：

public class Hashtable<K,V>
    extends Dictionary<K,V>
    implements Map<K,V>, Cloneable, java.io.Serializable {
    	//...
    	public synchronized boolean isEmpty() {
        	return count == 0;
    	}
    	//...
    }
  1. 首先，从定义上我们可以看出来，HashTable继承自Dictionary<K,V>，而HashMap继承自
    AbstractMap<K,V>，两者均实现了Map<K,V>接口
  2. 初始化容量不同：HashMap 的初始容量为：16，Hashtable 初始容量为：11两者的负载因子默认都是：0.75。
  3. 扩容机制不同：当现有容量大于总容量 * 负载因子时，HashMap 扩容规则为当前容量翻倍，Hashtable 扩容规则为当前容量翻倍 + 1。
  4. 迭代器不同：HashMap 中的 Iterator 迭代器是 fail-fast 的，而 Hashtable 的 Enumerator 不是 fail-fast 的。
    所以，当其他线程改变了HashMap 的结构，如：增加、删除元素，将会抛出ConcurrentModificationException 异常，而 Hashtable 则不会。

悦读

道可道，非常道；名可名，非常名。 无名，天地之始，有名，万物之母。 故常无欲，以观其妙，常有欲，以观其徼。 此两者，同出而异名，同谓之玄，玄之又玄，众妙之门。

最新收录
随机抽取学号
MUNIK解读ISO26262--硬件开发阶段详解
Android4.4电源管理——电源锁
MYSQL 七、mysql 日志与备份
Ubuntu24.04安装vulhub
[网络基础]——IP、MAC、子网掩码
MongoTemplate 性能优化指南
Liunx 常用命令50个
js判断上传的附件大小
【C++STL杂货铺】2万字总结学习进阶必学的两座大山：继承 && 多态（重点详解）
;