上一章节讲述了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的设计。