包括四种容器：
ConcurrentHashMap
ConcurrentLinkedQueue
ConcurrentMap
ConcurrentNavigableMap
其中ConcurrentLinkedQueue是并发环境下非阻塞算法的典型实现。
1.ConcurrentMap
ConcurrentMap是继承Map的一种interface，定义了一下几个api接口：
1
2
3
4
5
6
| public interface ConcurrentMap<K, V> extends Map<K, V> {
V putIfAbsent(K key, V value);
boolean remove(Object key, Object value);
boolean replace(K key, V oldValue, V newValue);
V replace(K key, V value);
}
|
2.ConcurrentNavigableMap
ConcurrentNavigableMap是继承ConcurrentMap的一种interface。
我们从SortedMap接口开始锁说，因为ConcurrentNavigableMap继承自NavigableMap，而NavigableMap继承自SortedMap。
2.1 SortedMap
实现SortedMap接口的类有排序功能，SortedMap相比普通Map提供了几个特殊的接口：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
| public interface SortedMap<K,V> extends Map<K,V> {
/**
* 返回key在 [fromKey, toKey)之间的子map的视图
*/
SortedMap<K,V> subMap(K fromKey, K toKey);
/**
* 返回key严格小于toKey的子map视图
*/
SortedMap<K,V> headMap(K toKey);
/**
* 返回key大于等于fromKey的子map视图
*/
SortedMap<K,V> tailMap(K fromKey);
/**
* 返回map中第一个key
*/
K firstKey();
/**
* 返回map中最后一个key
*/
K lastKey();
}
|
2.2 NavigableMap
NavigableMap扩展的 SortedMap，具有了针对给定搜索目标返回最接近匹配项的导航方法。方法 lowerEntry、floorEntry、ceilingEntry 和 higherEntry 分别返回与小于、小于等于、大于等于、大于给定键的键关联的 Map.Entry 对象，如果不存在这样的键，则返回 null。类似地，方法 lowerKey、floorKey、ceilingKey 和 higherKey 只返回关联的键。
可以按照键的升序或降序访问和遍历 NavigableMap。descendingMap 方法返回映射的一个视图，该视图表示的所有关系方法和方向方法都是逆向的。升序操作和视图的性能很可能比降序操作和视图的性能要好。
此接口还定义了 firstEntry、pollFirstEntry、lastEntry 和 pollLastEntry 方法，它们返回和/或移除最小和最大的映射关系（如果存在），否则返回 null。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
| public interface NavigableMap<K,V> extends SortedMap<K,V> {
/**
* 返回Map中严格小于给定key的最大的Entry，不存在则返回null
*/
Map.Entry<K,V> lowerEntry(K key);
/**
* 返回Map中严格小于给定key的最大的key，不存在则返回null
*/
K lowerKey(K key);
/**
* 返回Map中小于等于给定key的最大的Entry，不存在则返回null
*/
Map.Entry<K,V> floorEntry(K key);
/**
* 返回Map中小于等于给定key的最大key，不存在则返回null
*/
K floorKey(K key);
/**
* 返回大于等于给定key的最小的Entry，不存在返回null
*/
Map.Entry<K,V> ceilingEntry(K key);
/**
* 返回大于等于给定key的最小的key，不存在返回null
*/
K ceilingKey(K key);
/**
* 返回严格大于给定key的最小的Entry，不存在返回null
*/
Map.Entry<K,V> higherEntry(K key);
/**
* 返回严格大于给定key的最小的key，不存在返回null
*/
K higherKey(K key);
/**
* 返回Map中key最小的Entry，不存在则返回null
*/
Map.Entry<K,V> firstEntry();
/**
* 返回Map中key最大的Entry，不存在则返回null
*/
Map.Entry<K,V> lastEntry();
/**
* 删除并返回Map中key最小的Entry
*/
Map.Entry<K,V> pollFirstEntry();
/**
* 删除并返回Map中key最大的Entry
*/
Map.Entry<K,V> pollLastEntry();
/**
* 返回当前Map的降序的视图
* 注意，降序Map依靠当前Map实现，因此改变当前Map或者这个降序Map都会反映在彼此上
*/
NavigableMap<K,V> descendingMap();
/**
* 返回当前Map的Key集合的试图
* 改变当前Map或者这个Set都会影响彼此
*/
NavigableSet<K> navigableKeySet();
/**
* 返回当前Map的降序顺序的Key集合的试图
* 和navigableKeySet一样，改变当前Map或者这个降序Set都会影响彼此
*/
NavigableSet<K> descendingKeySet();
/**
* 返回key在[fromKey, toKey]之间的试图，如果fromInclusive为true，结果中包含fromKey
* 对应Entity，如果toInclusive为跳入额， 则结果中包含了toKey对应Entity
*/
NavigableMap<K,V> subMap(K fromKey, boolean fromInclusive,
K toKey, boolean toInclusive);
/**
* 返回key小于(如果inclusive为true，则包括等于)toKey的视图
*/
NavigableMap<K,V> headMap(K toKey, boolean inclusive);
/**
* 返回key大于(如果inclusive为true，则包括等于)fromKey的视图
*/
NavigableMap<K,V> tailMap(K fromKey, boolean inclusive);
}
|
同时NavigableMap也包含了三个返回SortedMap的接口
1
2
3
4
5
| SortedMap<K,V> subMap(K fromKey, K toKey);
SortedMap<K,V> headMap(K toKey);
SortedMap<K,V> tailMap(K fromKey);
|
2.3 ConcurrentNavigableMap
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
| ConcurrentNavigableMap继承了ConcurrentMap和NavigableMap两个接口：
public interface ConcurrentNavigableMap<K,V>
extends ConcurrentMap<K,V>, NavigableMap<K,V>
{
ConcurrentNavigableMap<K,V> subMap(K fromKey, boolean fromInclusive,
K toKey, boolean toInclusive);
ConcurrentNavigableMap<K,V> headMap(K toKey, boolean inclusive);
ConcurrentNavigableMap<K,V> tailMap(K fromKey, boolean inclusive);
ConcurrentNavigableMap<K,V> subMap(K fromKey, K toKey);
ConcurrentNavigableMap<K,V> headMap(K toKey);
ConcurrentNavigableMap<K,V> tailMap(K fromKey);
ConcurrentNavigableMap<K,V> descendingMap();
public NavigableSet<K> navigableKeySet();
NavigableSet<K> keySet();
public NavigableSet<K> descendingKeySet();
}
|
3.ConcurrentLinkedQueue
ConcurrentLinkedQueue是非阻塞算法的典型实现，因此单独写了一篇。
http://xiaobaoqiu.github.io/blog/2014/12/24/concurrentlinkedqueue/
4.ConcurrentHashMap
ConcurrentHashMap值得研究，也单独写了一篇。
http://xiaobaoqiu.github.io/blog/2014/12/24/concurrenthashmap/
5.参考
https://www.ibm.com/developerworks/cn/java/j-lo-concurrent/