11.并发编程--同步类容器和并发类容器

并发编程--同步类容器和并发类容器

同步类容器：

• - Vector
• - HashTable

并发类容器

• - ConcurrentMap
• - CopyOnWrite

同步类容器:

• * 同步类容器 都是线程安全的，但是在某些场景下可能需要加锁来保护复合操作。复合类操作如：迭代（反复访问元素，遍历容器中所有元素），跳转（根据指定的顺序找到当前元素的下一个元素），以及条件运算。

这些复合操作在多线程并发的修改容器时候，可能会变现出预期之外的情况：最为经典的便是：ConcurrentModificationException 原因就是当容器在迭代过程中，被并发的修改了内容。

• * 对于非同步类容器也可以同步Collections.synchronized***（Collections.synchronizedList(Collection c)/Collections.synchronizedMap/Collections.synchronizedSet）等方法进行使其变得安全
• 这些容器的同步功能其实都是通过JDK的Collections.synchronized***等工厂方法去创建实现的，其底层的机制就是使用传统的synchronized关键字对每个公用的方法进行同步处理。是的每次只有一个线程访问。
• 这些容器的性能较为底下，并不能满足高并发场景下的需求；

示例：Tickets.java

 1 import java.util.Collections;
 2 import java.util.HashMap;
 3 import java.util.Iterator;
 4 import java.util.Map;
 5 import java.util.Vector;
 6 
 7 /**
 8 * 多线程使用Vector或者HashTable的示例（简单线程同步问题）
 9 * @@author Maozw
10 */
11 public class Tickets {
12 
13     public static void main(String[] args) {
14       //初始化火车票池并添加火车票:避免线程同步可采用Vector替代ArrayList  HashTable替代HashMap
15 
16       final Vector tickets = new Vector();
17 
18       //Map map = Collections.synchronizedMap(new HashMap());
19 
20       for(int i = 1; i<= 1000; i++){
21         tickets.add("火车票"+i);
22       }
23 
24     //        for (Iterator iterator = tickets.iterator(); iterator.hasNext();) {
25     //            String string = (String) iterator.next();
26     //            tickets.remove(20);
27     //        }
28 
29       for(int i = 1; i <=10; i ++){
30         new Thread("线程"+i){
31           public void run(){
32             while(true){
33               if(tickets.isEmpty()) break;
34               System.out.println(Thread.currentThread().getName() + "---" + tickets.remove(0));
35             }
36           }
37         }.start();
38       }
39     }
40 }

并发类容器

• * JDK1.5 以后提供了很多并发类的容器来代替同步类容器，从而使得性能得到改善；同步类容器的状态都是串行化的，虽然是线程安全的，但是严重降低了并发性能，在多线程环境下，会严重影响系统的性能--吞吐量
• * 并发类容器是专门针对并发设计的，使用ConcurrentHashMap来替代给予散列的传统的HashTable。而且ConcurrentHashMap中添加了一些常见的复合操作的支持；
• * 以及使用了CopyOnWriteArrayList代替Voctor,
• * CopyOnWriteArraySet
• * 以及并发的Queue : ConcurrentLinkedQueue ConcurrentBlockingQueue 前者是高性能的队列，后者是以阻塞形式的队列；
• * 还有很多：ArrayBlockingQueue PriorityBlockingQueue SynchronousQueue等

ConcurrentMap
ConcurrentMap接口主要有两个重要的实现：

• * ConcurrentHashMap
• * ConcurrentSkipLinkedMap : 支持并发排序，弥补ConcurrentHashMap

ConcurrentHashMap 内部使用了段（Segment）来表示这些不同的部分，每个段其实就是一个小的HashTable，它们有自己的锁机制。只要多个修改操作发生在不同的段上，就可以并发的进行操作。
ConcurrentHashMap把一个整体分成16个段（Segment）。也就是说明最高支持16个线程的并发修改操作。这也是在多线程场景是减小锁的粒度从而降低锁竞争的一种方案。
ConcurrentHashMap并且代码中大多共享变量使用了volatile关键字声明。其目的就是第一个时间获取修改的内容，性能非常好。
示例：简单使用

 1 public class MyConcurrentMap {
 2 
 3     public static void main(String[] args) {
 4       ConcurrentHashMap chm = new ConcurrentHashMap();
 5       chm.put("k1", "v1");
 6       chm.put("k2", "v2");
 7       chm.put("k3", "v3");
 8       chm.putIfAbsent("k4", "vvvv");
 9       //System.out.println(chm.get("k2"));
10       //System.out.println(chm.size());
11 
12       for(Map.Entry me : chm.entrySet()){
13         System.out.println("key:" + me.getKey() + ",value:" + me.getValue());
14       }
15     }
16 }

CopyOnWrite 容器
Copy-On-Write简称COW，是一种用于程序设计中的优化策略。
其基本思路是，从一开始大家都在共享同一个内容，当某个人想要修改这个内容的时候，才会真正把内容Copy出去形成一个新的内容然后再改，这是一种延时懒惰策略。
从JDK1.5开始Java并发包里提供了两个使用CopyOnWrite机制实现的并发容器 ：

• * CopyOnWriteArrayList
• * CopyOnWriteArraySet。

CopyOnWrite容器非常有用，可以在非常多的并发场景中使用到。
CopyOnWrite容器即写时复制的容器。通俗的理解是当我们往一个容器添加元素的时候，不直接往当前容器添加，而是先将当前容器进行Copy，复制出一个新的容器，然后新的容器里添加元素，添加完元素之后，再将原容器的引用指向新的容器。
这样做的好处是我们可以对CopyOnWrite容器进行并发的读，而不需要加锁，因为当前容器不会添加任何元素。所以CopyOnWrite容器也是一种读写分离的思想，读和写不同的容器。
实现原理：
CopyOnWriteArrayList的实现原理
在使用CopyOnWriteArrayList之前，我们先阅读其源码了解下它是如何实现的。以下代码是向ArrayList里添加元素，可以发现在添加的时候是需要加锁的，否则多线程写的时候会Copy出N个副本出来。
示例：可以查看源码：

 1 /**
 2   * Appends the specified element to the end of this list.
 3   *
 4   * @param e element to be appended to this list
 5   * @return {@code true} (as specified by {@link Collection#add})
 6   */
 7  public boolean add(E e) {
 8      final ReentrantLock lock = this.lock;
 9      lock.lock();
10      try {
11          Object[] elements = getArray();
12          int len = elements.length;
13          Object[] newElements = Arrays.copyOf(elements, len + 1); // 复制出新数组
14          newElements[len] = e; // 把新元素添加到新数组里
15 
16          setArray(newElements); // 把原数组引用指向新数组
17          return true;
18      } finally {
19          lock.unlock();
20      }
21  }

读的时候不需要加锁，如果读的时候有多个线程正在向ArrayList添加数据，读还是会读到旧的数据，因为写的时候不会锁住旧的ArrayList。

1 /**
2            * {@inheritDoc}
3            *
4            * @throws IndexOutOfBoundsException {@inheritDoc}
5            */
6           public E get(int index) {
7               return get(getArray(), index);
8           }

 

转载于:https://www.cnblogs.com/Mao-admin/p/9989011.html