JUC——并发集合类

学习编程 2018-05-21

如果要进行多个数据的保存，无疑首选类集（List、Set、Queue、Map），在类集的学习的时候也知道一个概念：许多集合的子类都具有同步与异步的差别，但是如果真的要在多线程之中去使用这些类，是否真的可以用呢？

范例：观察一下类集的问题：

package so.strong.mall.concurrent;
import java.util.ArrayList;
import java.util.List;

public class ListDemo {
    public static void main(String[] args) {
        final List<String> all = new ArrayList<>();
        for (int i = 0; i < 20; i++) {
            final int temp = i;
            new Thread(new Runnable() {
                @Override
                public void run() {
                    for (int j = 0; j < 20; j++) {
                        all.add(Thread.currentThread().getName() + "-" + temp + "-" + j);
                        System.out.println(all);
                    }
                }
            }).start();
        }
    }
}
JUC——并发集合类

不过很遗憾的是这个时候以上的代码出现了“java.util.ConcurrentModificationException”，该异常主要指的是当保存的容量个数和实际操作数可能不匹配的时候就出现该异常。

并发集合类

为了更好的实现集合的高并发访问处理，juc中创建一组新的集合工具类:

List和Set集合

public class CopyOnWriteArrayList<E> implements List<E>, RandomAccess, Cloneable, java.io.Serializable

CopyOnWriteArrayList相当于线程安全的ArrayList，它实现了List接口。CopyOnWriteArrayList是支持高并发的。

public class CopyOnWriteArraySet<E> extends AbstractSet<E> implements java.io.Serializable

相当于线程安全的HashSet，它继承与AbstractSet类。

CopyOnWriteArraySet内部包含一个CopyOnWriteArrayList对象，它是通过CopyOnWriteArrayList来实现的。

Map集合

public class ConcurrentHashMap<K, V> extends AbstractMap<K, V> implements ConcurrentMap<K, V>, Serializable　

ConcurrentHashMap是线程安全的哈希表，相当于线程安全的HashMap，它继承与AbstractMap类，并且实现了ConcurrentMap接口。ConcurrentHashMap是通过“锁分段”来实现的，它支持并发；

public class ConcurrentSkipListMap<K,V> extends AbstractMap<K,V> implements ConcurrentNavigableMap<K,V>,Cloneable,java.io.Serializable

ConcurrentSkipListMap是线程安全的有序哈希表（相当于线程安全的TreeMap），它继承于AbstractMap类，并且实现了ConcurrentNavigableMap接口。ConcurrentSkipListMap是通过“跳表”来实现的，它支持并发；

public class ConcurrentSkipListSet<E> extends AbstractSet<E> implements NavigableSet<E>, Cloneable, java.io.Serializable

ConcurrentSkipListSet是线程安全的有序的集合（相当于线程安全的TreeSet）；它继承了AbstractSet，并且实现了NavigableSet接口。ConcurrentSkipListSet是通过ConcurrentSkipListMap实现的，它也支持并发。

Queue队列

public class ArrayBlockingQueue<E> extends AbstractQueue<E> implements BlockingQueue<E>, java.io.Serializable

ArrayBlockingQueue是数组实现的线程安全的有界的阻塞队列；

public class LinkedBlockingQueue<E> extends AbstractQueue<E>implements BlockingQueue<E>, java.io.Serializable

LinkedBlockingQueue是单向链表实现的（指定大小）阻塞队列，该队里按FIFO先进先出排序元素；

public class LinkedBlockingDeque<E>extends AbstractQueue<E> implements BlockingDeque<E>,  java.io.Serializable

LinkedBlockingDeque是双向链表实现的（指定大小）双向并发阻塞队列，该阻塞队列同时支持FIFO和FILO两种操作方式；

public class ConcurrentLinkedQueue<E> extends AbstractQueue<E> implements Queue<E>, java.io.Serializable

ConcurrentLinkedQueue是单向链表实现的无界队列，该队列按FIFO排序元素；

public class ConcurrentLinkedDeque<E> extends AbstractCollection<E> implements Deque<E>, java.io.Serializable

ConcurrentLinkedDeque是双向链表的无界队列，该阻塞队列同时支持FIFO和FILO两种操作方式。

单值并发集合

juc包里面提供的CopyOnWriteArrayList、CopyOnWriteArraySet很明显是针对于List和Set接口实现的子类。

范例：使用CopyOnWriteArrayList实现多线程访问

package so.strong.mall.concurrent;
import java.util.List;
import java.util.concurrent.CopyOnWriteArrayList;

public class ListDemo {
    public static void main(String[] args) {
        final List<String> all = new CopyOnWriteArrayList<>();
        for (int i = 0; i < 20; i++) {
            final int temp = i;
            new Thread(new Runnable() {
                @Override
                public void run() {
                    for (int j = 0; j < 20; j++) {
                        all.add(Thread.currentThread().getName() + "-" + temp + "-" + j);
                        System.out.println(all);
                    }
                }
            }).start();
        }
    }
}

范例：使用CopyOnWriteArraySet实现多线程访问

package so.strong.mall.concurrent;
import java.util.Set;
import java.util.concurrent.CopyOnWriteArraySet;

public class ListDemo {
    public static void main(String[] args) {
        final Set<String> all = new CopyOnWriteArraySet<>();
        for (int i = 0; i < 20; i++) {
            final int temp = i;
            new Thread(new Runnable() {
                @Override
                public void run() {
                    for (int j = 0; j < 20; j++) {
                        all.add(Thread.currentThread().getName() + "-" + temp + "-" + j);
                        System.out.println(all);
                    }
                }
            }).start();
        }
    }
}

如果某一个类需要存储用户的公共资源，并且多个线程允许同时写入数据的话，就可以考虑使用此类集合实现处理。

ConcurrentHashMap

观察继承结构：

public class ConcurrentHashMap<K, V> extends AbstractMap<K, V>
        implements ConcurrentMap<K, V>, Serializable

发现它是ConcurrentMap接口的子类，而ConcurrentMap接口定义如下：

public interface ConcurrentMap<K, V> extends Map<K, V>
JUC——并发集合类

范例：默认情况下使用ConcurrentHashMap的基本使用：

package so.strong.mall.concurrent;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;

public class ConcurrentHashMapDemo {
    public static void main(String[] args) {
        final Map<String, String> all = new ConcurrentHashMap<>();
        for (int i = 0; i < 2; i++) {
            final int temp = i;
            new Thread(new Runnable() {
                @Override
                public void run() {
                    for (int j = 0; j < 3; j++) {
                        all.put(Thread.currentThread().getName(), "x = " + temp + ",j = " + j);
                        System.out.println(all);
                    }
                }
            }).start();
        }
    }
}

使用ConcurrentHashMap并不仅仅是去解决“java.util.ConcurrentModificationException”异常，Map集合的主要特征是做数据的查询操作，所以在ConcurrentHashMap设计的时候考虑到了数据更新的安全性和数据查询的并发性。

JUC——并发集合类

ConcurrentHashMap的整体特征：写的时候同步写入，使用独占锁，读的时候为了保证性能使用了共享锁。

跳表（Skip）集合

跳表集合本质上的功能是一种快速查询功能，也就是说它会在一个有序的链表里面选择一些数据作为检索的种子数，那么利用这些种子数方便进行数据的查找，非常类似于二分法。

在juc开发包里面提供有跳表的多线程支持程序类：ConcurrentSkipListMap、ConcurrentSkipListSet。

范例：观察跳表实现ConcurrentSkipListMap

package so.strong.mall.concurrent;
import com.sun.scenario.effect.impl.sw.sse.SSEBlend_SRC_OUTPeer;
import sun.java2d.pipe.SpanIterator;
import java.util.Map;
import java.util.concurrent.ConcurrentSkipListMap;

public class SkipDemo {
    public static void main(String[] args) {
        final Map<String, String> all = new ConcurrentSkipListMap<>();
        for (int i = 0; i < 20; i++) {
            final int temp = i;
            new Thread(new Runnable() {
                @Override
                public void run() {
                    for (int j = 0; j < 30; j++) {
                        all.put(Thread.currentThread().getName(), "x=" + temp + ",j=" + j);
                    }
                }
            }).start();
        }
        System.out.println(all.get("Thread-0"));
    }

}

范例：使用ConcurrentSkipListSet

package so.strong.concurrents;
import java.util.Set;
import java.util.concurrent.ConcurrentSkipListSet;

public class SkipDemo {
    public static void main(String[] args) {
        final Set<String> all = new ConcurrentSkipListSet<>();
        for (int i = 0; i < 2; i++) {
            final int temp = i;
            new Thread(new Runnable() {
                @Override
                public void run() {
                    for (int j = 0; j < 10; j++) {
                        all.add(Thread.currentThread().getName()+"-"+temp+"-"+j);
                    }
                }
            }).start();
        }
        System.out.println(all.contains("Thread-0-0-1"));
    }
}

如果要想保证快速地定位查询，那么使用跳表是最快速的，因为其检索的算法要比顺序检索强许多。

学习编程

学习编程

相关推荐

JUC包中的CountDownLatch源码实现分析

CountDownLatch是JUC包中提供的线程同步工具，使用CountDownLatch可以实现一个或多个线程等待直到一组操作在其他线程中被执行完成。CountDownLatch基于AQS实现,代码不多,所以很好分析。// Decrement coun

zhujiangtaotaise / 0评论 2019-12-26

Java并发指南7：JUC的核心类AQS详解

本文有点长，但是很简单很简单很简单，主要面向读者对象为并发编程的初学者，或者想要阅读java并发包源码的开发者。本文大量使用我们平时用得最多的 ReentrantLock 的概念，本质上来说是不正确的，读者应该清楚，AQS 不仅仅用来实现锁，只是希望读者可

少年阿涛 / 0评论 2019-09-08

2019年Java面试-并发容器篇

我将JUC包中的集合类划分为3部分来进行说明。在简单的了解JUC包中集合类的框架之后，后面的章节再逐步对各个类进行介绍。List和SetMapQueue全网唯一一个从0开始帮助Java开发者转做大数据领域的公众号~公众号大数据技术与架构或者搜索import

cocleon / 0评论 2019-07-01

Java并发多线程 - 并发工具类JUC

例如，应用程序的主线程希望在负责启动框架服务的线程已经启动所有框架服务之后执行。CountDownLatch是通过一个计数器来实现的，计数器的初始化值为线程的数量。当计数器到达0时，表示所有的线程都已完成任务，然后在闭锁上等待的线程就可以恢复执行任务。

讨厌什么变成什么 / 0评论 2019-06-30

Java线程池架构(一)原理和源码解析

在前面介绍JUC的文章中，提到了关于线程池Execotors的创建介绍，在文章：《java之JUC系列-外部Tools》中第一部分有详细的说明，请参阅；在《java之JUC系列-外部Tools》文章中提到了构造方法，为了和本文对接，再贴下代码。我们现在来看

caiqianzhigai0 / 0评论 2013-06-08

JUC——线程同步辅助工具类（Semaphore，CountDownLatch，CyclicBarrier）

锁的机制从整体的运行转态来讲核心就是：阻塞，解除阻塞，但是如果仅仅是这点功能，那么JUC并不能称为一个优秀的线程开发框架，然而是因为在juc里面提供了大量方便的同步工具辅助类。Semaphore信号量Semaphore通常用于限制可以访问某些资源的线程数目

稀土 / 0评论 2018-05-11

JUC——线程同步锁（LockSupport阻塞原语）

但是在JDK1.5开发JUC框架之后，考虑到JUC框架之中的各种实现机制时开始试图还原之前被废弃的操作，于是就有了LockSupport这个类。LockSupport.unpark; //不管线程的操作如何，都要解除挂起状态

稀土 / 0评论 2018-05-07

JUC——原子类操作（三）

原子类操作既然强调了并发访问，那么就必须考虑操作系统位数：32位操作系统还是64位操作系统，对于long型数据类型而言，是64位的。但是如果现在项目运行在32位系统上，则long型数据会占用32位空间进行数据的保存。原子操作分类原子操作：是指操作过程中不会

数据分析侠 / 0评论 2018-04-24

JUC——JUC开发简介（一）

前言JUC是Java5.0开始提供的一组专门实现多线程并发处理的开发框架，利用JUC开发架构可以有效的解决实际线程项目开发之中出现的死锁、阻塞、资源访问与公平机制。此学习笔记来源于课程MLDN《JUC线程框架深度讲解》，有兴趣的小伙伴们可以购买学习！JUC

稀土 / 0评论 2018-04-24

【 初识】-JUC·Executor框架

前言多线程和并发这两个东西真的是向往已久，总是有一种神秘的感觉，想去探索一波，又担心水平不够无法驾驭。所以在阅读spring源码的同时，也想抽点时间来看一看JUC的东西，关于这块只能说是记录自己学习JUC的一个过程，尝试用一些具体的代码demo来加深理解。

稀土 / 0评论 2018-02-06

Java并发编程序列之JUC中Condition线程通讯

Java并发编程序列之JUC中Condition线程通讯Hello,大家好，前面给大家讲解synchronized关键字时给大家讲了下线程间的通讯，wait和notify.这两个API都是定义在Object中的方法，今天要给大家讲的是JUC中的Condit

稀土 / 0评论 2017-12-28

Java并发编程序列之JUC底层AQS(二)

Java并发编程序列之JUC底层AQS(二)Hello,大家好，在上一篇文章中，作者简单的把Lock接口和AQS的API，以及关系大致说了一下，本文还是围绕AQS为话题(AQS是重中之重，这个搞明白了。后面JUC自己看源码都很Easy可以看懂)，先具体到A

稀土 / 0评论 2017-12-22

Java并发编程序列之JUC底层AQS

Java并发编程序列之JUC底层AQS谈到JUC，Lock接口，大家肯定都会用。本文作为JUC的开头，先把Lock接口和AQS的API说一下，然后说清楚Lock和AQS的关系。Lock,AQS的相关APIAQS和Lock接口的关系1. Lock,AQS的

稀土 / 0评论 2017-12-20