Java同步容器和并发容器详解

同步容器

在 java 中，同步容器主要包括 2 类：

• vector、stack、hashtablecollections 类中提供的静态工厂方法创建的类（由 collections.synchronizedxxxx 等方法）
• collections类中提供的静态工厂方法创建的类

vector 实现了 list 接口，vector 实际上就是一个数组，和 arraylist 类似，但是vector 中的方法都是 synchronized 方法，即进行了同步措施。

stack 也是一个同步容器，它的方法也用 synchronized 进行了同步，它实际上是继承于 vector 类。

hashtable 实现了 map 接口，它和 hashmap 很相似，但是 hashtable 进行了同步处理，而 hashmap 没有。

同步容器的缺陷

同步容器的同步原理就是在方法上用 synchronized 修饰。那么，这些方法每次只允许一个线程调用执行。

性能问题

由于被 synchronized 修饰的方法，每次只允许一个线程执行，其他试图访问这个方法的线程只能等待。显然，这种方式比没有使用 synchronized 的容器性能要差。

安全问题

同步容器真的一定安全吗？

答案是：未必。同步容器未必真的安全。在做复合操作时，仍然需要加锁来保护。

常见复合操作如下：

• 迭代：反复访问元素，直到遍历完全部元素；
• 跳转：根据指定顺序寻找当前元素的下一个（下 n 个）元素；
• 条件运算：例如若没有则添加等；

不安全的示例

<pre style="margin: 0px; padding: 0px; white-space: pre-wrap; overflow-wrap: break-word; font-family: "courier new" !important; font-size: 12px !important;">public class test { static vector<integer> vector = new vector<integer>();
public static void main(string[] args) throws interruptedexception {
while(true) {
for (int i=0;i<10;i++)
vector.add(i);
thread thread1 = new thread(){
public void run() {
for (int i=0;i<vector.size();i++)
vector.remove(i);
}
;
}
;
thread thread2 = new thread(){
public void run() {
for (int i=0;i<vector.size();i++)
vector.get(i);
}
;
}
;
thread1.start();
thread2.start();
while(thread.activecount()>10) {
}
}
}
}
</pre>

执行时可能会出现数组越界错误。

vector 是线程安全的，为什么还会报这个错？很简单，对于 vector，虽然能保证每一个时刻只能有一个线程访问它，但是不排除这种可能：
当某个线程在某个时刻执行这句时：

<pre style="margin: 0px; padding: 0px; white-space: pre-wrap; overflow-wrap: break-word; font-family: "courier new" !important; font-size: 12px !important;">for (int i=0;i<vector.size();i++)
vector.get(i);
</pre>

假若此时 vector 的 size 方法返回的是 10，i 的值为 9

然后另外一个线程执行了这句：

<pre style="margin: 0px; padding: 0px; white-space: pre-wrap; overflow-wrap: break-word; font-family: "courier new" !important; font-size: 12px !important;">for (int i=0;i<vector.size();i++)
vector.remove(i);
</pre>

将下标为 9 的元素删除了。

那么通过 get 方法访问下标为 9 的元素肯定就会出问题了。

安全示例

因此为了保证线程安全，必须在方法调用端做额外的同步措施，如下面所示：

public class test {
static vector<integer> vector = new vector<integer>();
public static void main(string[] args) throws interruptedexception {
while(true) {
for (int i=0;i<10;i++)
vector.add(i);
thread thread1 = new thread(){
public void run() {
synchronized (test.class) {
//进行额外的同步
for (int i=0;i<vector.size();i++)
vector.remove(i);
}
}
;
}
;
thread thread2 = new thread(){
public void run() {
synchronized (test.class) {
for (int i=0;i<vector.size();i++)
vector.get(i);
}
}
;
}
;
thread1.start();
thread2.start();
while(thread.activecount()>10) {
}
}
}
}

concurrentmodificationexception 异常

在对 vector 等容器并发地进行迭代修改时，会报 concurrentmodificationexception 异常，关于这个异常将会在后续文章中讲述。

但是在并发容器中不会出现这个问题。

并发容器

jdk 的 java.util.concurrent 包（即 juc）中提供了几个非常有用的并发容器。

• copyonwritearraylist - 线程安全的 arraylist
• copyonwritearrayset - 线程安全的 set，它内部包含了一个 copyonwritearraylist，因此本质上是由 copyonwritearraylist 实现的。
• concurrentskiplistset - 相当于线程安全的 treeset。它是有序的 set。它由 concurrentskiplistmap 实现。
• concurrenthashmap - 线程安全的 hashmap。采用分段锁实现高效并发。
• concurrentskiplistmap - 线程安全的有序 map。使用跳表实现高效并发。
• concurrentlinkedqueue - 线程安全的*队列。底层采用单链表。支持 fifo。
• concurrentlinkeddeque - 线程安全的*双端队列。底层采用双向链表。支持 fifo 和 filo。
• arrayblockingqueue - 数组实现的阻塞队列。
• linkedblockingqueue - 链表实现的阻塞队列。
• linkedblockingdeque - 双向链表实现的双端阻塞队列。

concurrenthashmap

要点

作用：concurrenthashmap 是线程安全的 hashmap。
原理：jdk6 与 jdk7 中，concurrenthashmap 采用了分段锁机制。jdk8 中，摒弃了锁分段机制，改为利用 cas 算法。

源码

jdk7

concurrenthashmap 类在 jdk1.7 中的设计，其基本结构如图所示：

每一个 segment 都是一个 hashentry<k,v>[] table， table 中的每一个元素本质上都是一个 hashentry 的单向队列。比如 table[3]为首节点，table[3]->next 为节点 1，之后为节点 2，依次类推。

<pre style="margin: 0px; padding: 0px; white-space: pre-wrap; overflow-wrap: break-word; font-family: "courier new" !important; font-size: 12px !important;">public class concurrenthashmap<k, v> extends abstractmap<k, v>
implements concurrentmap<k, v>, serializable { // 将整个hashmap分成几个小的map，每个segment都是一个锁；与hashtable相比，这么设计的目的是对于put, remove等操作，可以减少并发冲突，对 // 不属于同一个片段的节点可以并发操作，大大提高了性能
final segment<k,v>[] segments;
// 本质上segment类就是一个小的hashmap，里面table数组存储了各个节点的数据，继承了reentrantlock, 可以作为互拆锁使用
static final class segment<k,v> extends reentrantlock implements serializable {
transient volatile hashentry<k,v>[] table;
transient int count;
}
// 基本节点，存储key， value值
static final class hashentry<k,v> {
final int hash;
final k key;
volatile v value;
volatile hashentry<k,v> next;
}
}
</pre>

jdk8

jdk8 中主要做了 2 方面的改进

• 取消 segments 字段，直接采用 transient volatile hashentry<k,v>[] table 保存数据，采用 table 数组元素作为锁，从而实现了对每一行数据进行加锁，进一步减少并发冲突的概率。
• 将原先 table 数组＋单向链表的数据结构，变更为 table 数组＋单向链表＋红黑树的结构。

对于 hash 表来说，最核心的能力在于将 key hash 之后能均匀的分布在数组中。如果 hash 之后散列的很均匀，那么 table 数组中的每个队列长度主要为 0 或者 1。

但实际情况并非总是如此理想，虽然 concurrenthashmap 类默认的加载因子为 0.75，但是在数据量过大或者运气不佳的情况下，还是会存在一些队列长度过长的情况，如果还是采用单向列表方式，那么查询某个节点的时间复杂度为 o(n)；

因此，对于个数超过 8(默认值)的列表，jdk1.8 中采用了红黑树的结构，那么查询的时间复杂度可以降低到 o(logn)，可以改进性能。

<pre style="margin: 0px; padding: 0px; white-space: pre-wrap; overflow-wrap: break-word; font-family: "courier new" !important; font-size: 12px !important;">final v putval(k key, v value, boolean onlyifabsent) {
if (key == null || value == null) throw new nullpointerexception();
int hash = spread(key.hashcode());
int bincount = 0;
for (node<k,v>[] tab = table;;) {
node<k,v> f;
int n, i, fh;
// 如果table为空，初始化；否则，根据hash值计算得到数组索引i，如果tab[i]为空，直接新建节点node即可。注：tab[i]实质为链表或者红黑树的首节点。
if (tab == null || (n = tab.length) == 0)
tab = inittable(); 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
}
// 如果tab[i]不为空并且hash值为moved，说明该链表正在进行transfer操作，返回扩容完成后的table。 else if ((fh = f.hash) == moved)
tab = helptransfer(tab, f); else {
v oldval = null;
// 针对首个节点进行加锁操作，而不是segment，进一步减少线程冲突
synchronized (f) {
if (tabat(tab, i) == f) {
if (fh >= 0) {
bincount = 1;
for (node<k,v> e = f;; ++bincount) {
k ek;
// 如果在链表中找到值为key的节点e，直接设置e.val = value即可。
if (e.hash == hash && ((ek = e.key) == key || (ek != null && key.equals(ek)))) {
oldval = e.val;
if (!onlyifabsent)
e.val = value;
break;
}
// 如果没有找到值为key的节点，直接新建node并加入链表即可。
node<k,v> pred = e;
if ((e = e.next) == null) {
pred.next = new node<k,v>(hash, key,
value, null);
break;
}
}
}
// 如果首节点为treebin类型，说明为红黑树结构，执行puttreeval操作。 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) {
// 如果节点数>＝8，那么转换链表结构为红黑树结构。
if (bincount >= treeify_threshold)
treeifybin(tab, i);
if (oldval != null) return oldval;
break;
}
}
}
// 计数增加1，有可能触发transfer操作(扩容)。
addcount(1l, bincount);
return null;
}
</pre>

示例

<pre style="margin: 0px; padding: 0px; white-space: pre-wrap; overflow-wrap: break-word; font-family: "courier new" !important; font-size: 12px !important;">public class concurrenthashmapdemo { public static void main(string[] args) throws interruptedexception { // hashmap 在并发迭代访问时会抛出 concurrentmodificationexception 异常 // map<integer, character> map = new hashmap<>();
map<integer, character> map = new concurrenthashmap<>();
thread wthread = new thread(() -> {
system.out.println("写操作线程开始执行"); for (int i = 0; i < 26; i++) {
map.put(i, (char) ('a' + i));
}
});
thread rthread = new thread(() -> {
system.out.println("读操作线程开始执行"); for (integer key : map.keyset()) {
system.out.println(key + " - " + map.get(key));
}
});
wthread.start();
rthread.start();
thread.sleep(1000);
}
}</pre>

copyonwritearraylist

要点

作用：copyonwrite 字面意思为写入时复制。copyonwritearraylist 是线程安全的 arraylist。

原理：

• 在 copyonwriteaarraylist 中，读操作不同步，因为它们在内部数组的快照上工作，所以多个迭代器可以同时遍历而不会相互阻塞（1,2,4）。
• 所有的写操作都是同步的。他们在备份数组（3）的副本上工作。写操作完成后，后备阵列将被替换为复制的阵列，并释放锁定。支持数组变得易变，所以替换数组的调用是原子（5）。
• 写操作后创建的迭代器将能够看到修改的结构（6,7）。
• 写时复制集合返回的迭代器不会抛出 concurrentmodificationexception，因为它们在数组的快照上工作，并且无论后续的修改（2,4）如何，都会像迭代器创建时那样完全返回元素。

源码

重要属性

• lock - 执行写时复制操作，需要使用可重入锁加锁
• array - 对象数组，用于存放元素

<pre style="margin: 0px; padding: 0px; white-space: pre-wrap; overflow-wrap: break-word; font-family: "courier new" !important; font-size: 12px !important;"> 
/** the lock protecting all mutators */
final transient reentrantlock lock = new reentrantlock();
/** the array, accessed only via getarray/setarray. */
private transient volatile object[] array;
</pre>

重要方法

添加操作

添加的逻辑很简单，先将原容器 copy 一份，然后在新副本上执行写操作，之后再切换引用。当然此过程是要加锁的。

<pre style="margin: 0px; padding: 0px; white-space: pre-wrap; overflow-wrap: break-word; font-family: "courier new" !important; font-size: 12px !important;">public boolean add(e e) {
//reentrantlock加锁，保证线程安全
final reentrantlock lock = this.lock;
lock.lock();
try {
object[] elements = getarray();
int len = elements.length;
//拷贝原容器，长度为原容器长度加一
object[] newelements = arrays.copyof(elements, len + 1);
//在新副本上执行添加操作
newelements[len] = e;
//将原容器引用指向新副本
setarray(newelements);
return true;
}
finally {
//解锁
lock.unlock();
}
}
</pre>

删除操作

删除操作同理，将除要删除元素之外的其他元素拷贝到新副本中，然后切换引用，将原容器引用指向新副本。同属写操作，需要加锁。

<pre style="margin: 0px; padding: 0px; white-space: pre-wrap; overflow-wrap: break-word; font-family: "courier new" !important; font-size: 12px !important;">public e remove(int index) {
//加锁
final reentrantlock lock = this.lock;
lock.lock();
try {
object[] elements = getarray();
int len = elements.length;
e oldvalue = get(elements, index);
int nummoved = len - index - 1;
if (nummoved == 0) //如果要删除的是列表末端数据，拷贝前len-1个数据到新副本上，再切换引用
setarray(arrays.copyof(elements, len - 1)); else {
//否则，将除要删除元素之外的其他元素拷贝到新副本中，并切换引用
object[] newelements = new object[len - 1];
system.arraycopy(elements, 0, newelements, 0, index);
system.arraycopy(elements, index + 1, newelements, index,
nummoved);
setarray(newelements);
}
return oldvalue;
}
finally {
//解锁
lock.unlock();
}
}
</pre>

读操作

copyonwritearraylist 的读操作是不用加锁的，性能很高。

<pre style="margin: 0px; padding: 0px; white-space: pre-wrap; overflow-wrap: break-word; font-family: "courier new" !important; font-size: 12px !important;">public e get(int index) {
return get(getarray(), index);
}
private e get(object[] a, int index) {
return (e) a[index];
}
</pre>

示例

<pre style="margin: 0px; padding: 0px; white-space: pre-wrap; overflow-wrap: break-word; font-family: "courier new" !important; font-size: 12px !important;">public class copyonwritearraylistdemo { static class readtask implements runnable {
list<string> list;
readtask(list<string> list) {
this.list = list;
}
public void run() {
for (string str : list) {
system.out.println(str);
}
}
}
static class writetask implements runnable {
list<string> list;
int index;
writetask(list<string> list, int index) {
this.list = list;
this.index = index;
}
public void run() {
list.remove(index);
list.add(index, "write_" + index);
}
}
public void run() {
final int num = 10;
// arraylist 在并发迭代访问时会抛出 concurrentmodificationexception 异常 // list<string> list = new arraylist<>();
copyonwritearraylist<string> list = new copyonwritearraylist<>();
for (int i = 0; i < num; i++) {
list.add("main_" + i);
}
executorservice executorservice = executors.newfixedthreadpool(num);
for (int i = 0; i < num; i++) {
executorservice.execute(new readtask(list));
executorservice.execute(new writetask(list, i));
}
executorservice.shutdown();
}
public static void main(string[] args) {
new copyonwritearraylistdemo().run();
}
}
</pre>

以上就是本文的全部内容，希望对大家的学习有所帮助，也希望大家多多支持。