同步类容器 & 并发类容器

最新推荐文章于 2023-05-08 22:58:28 发布

Martiny66

最新推荐文章于 2023-05-08 22:58:28 发布

阅读量166

点赞数

分类专栏： Java并发文章标签： Java 并发容器

本文链接：https://blog.csdn.net/xzx4959/article/details/83388118

版权

Java并发专栏收录该内容

19 篇文章 0 订阅

订阅专栏

一.同步类容器

同步类容器是线程安全的，但在某些场景下可能需要加锁来保护复合操作，例如：迭代（反复访问元素，元素的遍历）、跳转（根据指定的顺序找到当前元素的下一个元素）以及条件运算。这些复合操作在多线程并发的修改容器时，可能会表现出意外的行为，最经典的是ConcurrentModificationException，原因是当容器迭代的过程中，被并发的修改了内容，这是由于早期迭代器设计的时候并没有考虑到并发修改的问题。看如下的代码，Vector虽然是线程安全的，但是在复合操作（迭代加修改元素）的时候，也是会抛出ConcurrentModificationException异常：

public class Tickets {

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

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

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

        for (Iterator iterator = tickets.iterator(); iterator.hasNext(); ) {
            String string = (String) iterator.next();
            System.out.println("当前元素：" + string);
            tickets.remove(20);
        }

    }
}

多线程非复合操作下，vector是线程安全的，如下实例代码：

public class Tickets {

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

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


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


		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();
		}
    }
}

各个线程不断的去移除元素，并未出现异常。

同步类容器：如古老的Vector、Hashtable。这些容器的同步功能其实都是有JDK的Collection.synchronized等工厂方法去创建实现的。其底层的机制无非就是用传统的synchronized关键字对每个公共的方法都进行同步，使得每次操作只能有一个线程去访问容器的状态。这很明显不满足我们今天互联网时代高并发的需求，无法保证足够的性能。

假如我们直接使用ArrayList，做并发的删除操作，会出现并发问题，代码如下：

public class Tickets {

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

        List<String> tickets = new ArrayList<String>();

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


        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();
        }
    }
}

输出的结果中，会出现打印为空的元素，从而证明ArrayList不是线程安全的。此时我们可以使用Collections.synchronizedList方法，将tickets设置为线程安全的。

public class Tickets {

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

        List<String> tickets = Collections.synchronizedList(new ArrayList<>());

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


        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();
        }
    }
}

二.并发类容器

jdk5.0以后提供了多种并发类容器来替代同步类容器从而改善性能，并发类容器时专门针对并发设计的：使用ConcurrentHashMap来代替基于散列的Hashtable，并添加了一些常见符合操作的支持；使用CopyOnWriteArrayList代替Vector，并发的CopyOnWriteArraySet，以及并发的Queue：ConcurrentLinkedQueue和LinkedBlockingQueue，前者是高性能的队列，后者是以阻塞形式的队列。具体形式的Queue还有很多如：ArrayBlockingQueue、PriorityBlockingQueue、SynchronousQueue等。

2.1 ConcurrentMap

ConcurrentMap接口有两个重要的实现：ConcurrentHashMap和ConcurrentSkipListMap（支持并发排序的功能，弥补ConcurrentHashMap的不足）。ConcurrentHashMap内部使用段（Segment）来表示这些不同的部分，每个段其实就是一个小的Hashtable，他们有自己的锁，只要多个修改操作发生在不同的段上，它们就可以并发执行。ConcurrentHashMap把一个整体分成了16个段，也就是最高支持16个线程的并发修改操作，这也是在多线程场景下减小锁的粒度从而降低锁竞争的一种方案，同时代码中大多数的共享变量使用volatile关键字声明，目的是第一时间获取修改的内容，性能非常好。

public class UseConcurrentMap {

    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("k3", "vvvv");
      

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

输出结果为：

key:k1,value:v1
key:k2,value:v2
key:k3,value:v3

在上面的结果中，k3的输出值是v3，并不是vvvv。putIfAbsent方法表示，如果当前key已经有值了，则不再添加当前元素了，否则会添加。

ConcurrentHashMap

ConcurrentHashMap是线程安全且高效的HashMap。为什么要使用ConcurrentHashMap？因为在并发编程中使用HashMap可能导致程序死循环，而使用线程安全的HashTable效率又非常低下。

线程不安全的HashMap

在多线程环境下，使用HashMap进行put操作会引起死循环，导致CPU的利用率接近100%，所以并发环境下不能使用HashMap。一般来说Hash表容器中当有容器要插入时，都会检查容量有没有超过设定的thredhold，如果超过，需要增大HASH表的尺寸，此时整个Hash表中的元素都要重新计算一遍并拷贝到新表中，这叫rehash。当多线程程序并发执行put操作引发Hash表扩容，进行rehash时，会导致HashMap的Entry链表形成环形数据结构，一旦形成环形数据结构，Entry的next节点永远不为空就会产生死循环获取Entry的情况。

效率低下的HashTable

HashTable容器使用synchronized来保证线程安全，但是线程竞争激烈的情况下HashTable的效率非常低下。

ConcurrentHashMap的锁分段技术可以提升并发访问率

Hashtable容器在竞争激烈的情况下表现出效率低下的主要原因是所有访问Hashtable的线程都必须竞争一把锁，而ConcurrentHashMap使用锁分段技术将数据分成一段一段的存储，然后给每一段数据配一把锁，当一个线程占用锁访问其中一个段数据的时候，其他段的数据也能被其他线程所访问。

ConcurrentHashMap的结构

ConcurrentHashMap是由Segment数组结构和HashEntry数组结构组成。Segment是一种可重入锁，在ConcurrentHashMap里面扮演锁的角色；HashEntry则用于存储键值对数据。一个ConcurrentHashMap里包含一个Segment数组，一个Segment里包含一个HashEntry数组，每个HashEntry是一个链表结构的元素，每个Segment守护着一个HashEntry数组里的元素，当对HashEntry数组的数据进行修改时，必须首先获得与它对应的Segment锁。ConcurrentHashMap的类图：

2.2 Copy-On-Write容器

copy-on-write简称COW，是一种用于程序设计中的优化策略。JDK中的COW容器有两种，CopyOnWriteArrayList和CopyOnWriteArraySet，COW容器非常的有用，可以在非常多的并发场景中使用到。

什么是CopyOnWrite容器？

CopyOnWrite容器即写时复制的容器，通俗的理解是当我们往一个容器添加元素的时候，不直接往当前容器添加，而是先将当前容器进行Copy，复制出一个新的容器，然后往新的容器里添加元素。元素添加完成之后，再将原容器的引用指向新的容器。这样做的好处是我们可以对CopyOnWrite容器进行并发的读，而不需要加锁，因为当前容器不会添加任何的元素，所以CopyOnWrite容器也是一种读写分离的思想，读和写不同的容器，非常适合读多写少的情况。CopyOnWriteArrayList读写分离的核心代码如下：

    /**
     * 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();
        }
    }

CopyOnWriteArraySet添加元素的实现代码如下：

 /**
     * A version of addIfAbsent using the strong hint that given
     * recent snapshot does not contain e.
     */
    private boolean addIfAbsent(E e, Object[] snapshot) {
        final ReentrantLock lock = this.lock;
        lock.lock();
        try {
            Object[] current = getArray();
            int len = current.length;
            if (snapshot != current) {
                // Optimize for lost race to another addXXX operation
                int common = Math.min(snapshot.length, len);
                for (int i = 0; i < common; i++)
                    if (current[i] != snapshot[i] && eq(e, current[i]))
                        return false;
                if (indexOf(e, current, common, len) >= 0)
                        return false;
            }
            Object[] newElements = Arrays.copyOf(current, len + 1);
            newElements[len] = e;
            setArray(newElements);
            return true;
        } finally {
            lock.unlock();
        }
    }