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

你可能感兴趣的:(11.并发编程--同步类容器和并发类容器)