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

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

同步类容器：

• - Vector
• - HashTable

并发类容器

• - ConcurrentMap
• - CopyOnWrite

同步类容器:

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

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

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

示例：Tickets.java

import java.util.Collections;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Vector;

/**
* 多线程使用Vector或者HashTable的示例（简单线程同步问题）
* @@author Maozw
*/
public class Tickets {

    public static void main(String[] args) {
      //初始化火车票池并添加火车票:避免线程同步可采用Vector替代ArrayList  HashTable替代HashMap

      final Vector<String> tickets = new Vector<String>();

      //Map<String, String> map = Collections.synchronizedMap(new HashMap<String, String>());

      for(int i = 1; i<= 1000; i++){
        tickets.add("火车票"+i);
      }

    //        for (Iterator iterator = tickets.iterator(); iterator.hasNext();) {
    //            String string = (String) iterator.next();
    //            tickets.remove(20);
    //        }

      for(int i = 1; i <=10; i ++){
        new Thread("线程"+i){
          public void run(){
            while(true){
              if(tickets.isEmpty()) break;
              System.out.println(Thread.currentThread().getName() + "---" + tickets.remove(0));
            }
          }
        }.start();
      }
    }
}

并发类容器

• * 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关键字声明。其目的就是第一个时间获取修改的内容，性能非常好。
示例：简单使用

public class MyConcurrentMap {

    public static void main(String[] args) {
      ConcurrentHashMap<String, Object> chm = new ConcurrentHashMap<String, Object>();
      chm.put("k1", "v1");
      chm.put("k2", "v2");
      chm.put("k3", "v3");
      chm.putIfAbsent("k4", "vvvv");
      //System.out.println(chm.get("k2"));
      //System.out.println(chm.size());

      for(Map.Entry<String, Object> me : chm.entrySet()){
        System.out.println("key:" + me.getKey() + ",value:" + me.getValue());
      }
    }
}

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

• * CopyOnWriteArrayList
• * CopyOnWriteArraySet。

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

/**
  * Appends the specified element to the end of this list.
  *
  * @param e element to be appended to this list
  * @return {@code true} (as specified by {@link Collection#add})
  */
 public boolean add(E e) {
     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();
     }
 }

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

/**
           * {@inheritDoc}
           *
           * @throws IndexOutOfBoundsException {@inheritDoc}
           */
          public E get(int index) {
              return get(getArray(), index);
          }