JUC——并发集合类

最新推荐文章于 2023-05-28 13:13:42 发布
最新推荐文章于 2023-05-28 13:13:42 发布
阅读量110 收藏
点赞数
文章标签： java 数据结构与算法
原文链接：http://www.cnblogs.com/itermis/p/9066144.html
版权

如果要进行多个数据的保存，无疑首选类集（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();
        }
    }
}

不过很遗憾的是这个时候以上的代码出现了“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>

范例：默认情况下使用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设计的时候考虑到了数据更新的安全性和数据查询的并发性。

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

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

 

转载于:https://www.cnblogs.com/itermis/p/9066144.html

weixin_33738555
关注
JUC高并发编程从入门到精通（全）
码农研究僧的博客
08-06 1万+
目录前言 前言 在了解这部分内容的时候 先要了解java的一些基础内容 java零基础从入门到精通（全） javaSE从入门到精通（全） 所谓JUC是java.util .concurrent 工具包的简称这是一个处理线程的工具包可以实现多线程高并发的内容 了解该部分内容先了解线程与进程的相关概念 【操作系统】线程与进程的深入剖析（全） java之Thread类详细分析（全） 以及涉及到的lambda表达式函数的概念 java中lambda表达式 ......
高级技术之 JUC 高并发编程
wa_ka_ka的博客
08-25 844
1，什么是 JUC 1.1 JUC简介 JUC 就是java.util.concurrent 工具包的简称，这一个专门用来处理线程的工具包，JDK1.5开始出现 1.2 进程与线程 **进程（Process）：**是系统进行资源分配和调度的基本单位，比如QQ启动就是一个进程。 **线程（Thread）：**是操作系统能够进行运算调度的最小单位，是程序执行的最小单位，它被包含在进程中，比如QQ中的各个功能，都是不同的线程。 1.3 线程的状态 在Thread类中枚举了线程的6种状态; pu
一篇与面试官和蔼交流的深入了解JUC并发编程+集合
马小婧QAQ
01-27 481
文章目录 1、Cas（比较并交换） 2、AQS（AbstractQueuedSynchronizer）=>抽象队列同步器 3、Volatile： 3.1、JMM 3.2、As-If-Serial原则 3.3、Happens-Before原则 3.4、volatile原理 3.5、作用 3.6、原子操作 3.7、高速缓存 3.8、MESI状态切换 3.9、伪共享 4、ReentrantLo
JUC-并发集合类
isaiah的专栏
08-19 881
在大家学习Java基础时都知道，ArrayList、LinkedList、HashMap、HashSet等常用的容器类都是线程不安全的，如果有多个线程访问它们时将会出现意外结果，下边我们讲解如果使用线程安全的集合类。 使用java.util包下线程安全的集合类 使用Collections工具类将非线程安全的集合包装成线程安全的集合 使用juc中的并发集合类 Vector与Hashtable ...
juc并发集合类_并发集合类
cusi77914的博客
06-30 615
出现在Java类库中的第一个关联集合类是Hashtable ，它是JDK 1.0的一部分。 Hashtable提供了易于使用，线程安全的关联映射功能，并且肯定很方便。 但是，线程安全是要付出代价的Hashtable所有方法都是同步的。 当时，无竞争的同步具有可衡量的性能成本。 Hashtable的后继者HashMap出现在JDK 1.2中的Collections框架中，它通过提供未同步的基类和...
☆JUC中安全的并发集合类
我能在河边钓一整天的鱼
05-31 320
CopyOnWriteArrayList List集合在单线程时是安全的，但多线程的情况下是不安全的。 public class ListTest { public static void main(String[] args) { List<String> list = new ArrayList<>(); for (int i = 0; i <= 10; i++) { new Threa...
JUC基本使用——并发集合和同步工具类
qq_45337431的博客
08-17 639
并发集合
JUC —— 集合类不安全
weixin_46540606的博客
02-08 282
List不安全 public class ListTest { public static void main(String[] args) { List<String> list = new ArrayList<>(); for(int i=1;i<=10;i++){ new Thread(()->{ list.add(UUID.randomUUID().toString()
JUC——JUC强大辅助类讲解
qq_44891295的博客
04-11 388
文章目录1：JUC是什么2：倒计数器——CountDownLatchDemo3：循环栅栏——CyclicBarrier4：允许多个线程同时访问——Semaphore（信号量） 1：JUC是什么 JUC全名java.util.concurrent是一种在并发编程中使用的工具类 JUC主要是三大包构成：并发包，并发原子包，并发lock包 如下介绍的三种辅助类都是在java.util.concurrent包下 2：倒计数器——CountDownLatchDemo CountDownLatch是一个非常实用的多线
juc并发集合类
weixin_43766256的博客
05-03 293
集合总览 Queue 接口 ConcurrentLinkedQueue 实现类 BlockingQueue 接口 ArrayBlockingQueue实现类 DelayQueue 实现类 PriorityBlockingQueue 实现类 SynchronousQueue实现类 Deque接口 ArrayDueue实现类 LinkedList实现类 BlockingDeque 接口 Linke...
juc学习笔记三-并发集合
weixin_43725192的博客
03-30 479
1 ConcurrentLinkedQueue HOPS延迟更新策略： tail：当前tail节点的下一个节点为null时，只插入节点但是不更新tail；当前tail节点的下一个节点不为null时，才会定位真正的tail。 head：当前head的item不为null时只删除节点不更新head；当前head的item为null的时候才定位新的head。 HOPS策略减少了CAS更新，采用无锁的方式，可以达到更高的并发。 2 BlockingQueue和BlockingDeque 2.1 简介 Blockin
JUC包中并发安全集合
希望和大家多多交流技术！
02-12 888
1、CopyOnWriteArrayList CopyOnWriteArrayList是并发安全的ArrayList，采用写时复制的策略 Object[]属性用来存放数组的元素 ReentrantLock属性是一个独占锁，为了保证同时只能有一个线程操作数组，实现并发安全 1、add（E e）方法 2、get（int index）方法 先获取数组 通过下标访问数组元素 整个过程没有上锁，从而导致的问题？——数据的弱一致问题 假设线程A在获取数组元素的过程中，另外一个线程B删除了这个元
JUC基础（四）—— 并发集合
战斧的博客
04-28 544
我们在JUC的开篇讲过，juc包主要包含以下部分：线程池 并发集合 同步器 原子变量 锁 并发工具类那么本次我们就来讲一讲并发集合
【JUC基础】11. 并发下的集合类
最新发布
有一只柴犬的专栏
05-28 958
我们直到ArrayList，HashMap等是线程不安全的容器。但是我们通常会频繁的在JUC中使用集合类，那么应该如何确保线程安全？
JUC中的锁、信号量、并发集合
weixin_53455615的博客
08-27 387
如果被请求的共享资源空闲，则将当前请求资源的线程设置为有效的工作线程，并且将共享资源设置为锁定状态。如果被请求的共享资源被占用， 获取不到锁的线程加入到队列中。suspend()和resume()是synchronized中的暂停和恢复。对该同步状态进行原子操作实现对其值的修改，当state大于0的时候表示锁被占用，如果state等于0时表示没有占用锁。：新添加的线程先尝试获取获取资源，若获取到之间执行此线程，若没有获取到就添加到队列中去排队。1. ReentrantLock(): 创建非公平锁的重入锁。.
并发编程-线程安全策略之并发容器（J.U.C）中的集合类
花&败
07-31 297
JUC 是 Java 5.0 之后新增的一个包，该包提供了一套并发编程的工具类，包括原子操作、线程池、Lock、Condition 等类，方便进行多线程编程的操作。JUC 的出现是为了解决多线程共享资源，协作完成任务时常见的问题，如同时访问共享资源、线程死锁、饥饿、并行性不足等问题。使用 JUC 提供的工具类可以简化并发程序的编写，提高程序的效率和稳定性同步容器是通过synchronized来实现同步的，所以性能较差。而且同步容器也并不是绝对线程安全的，在一些特殊情况下也会出现线程不安全的行为。
JUC及Tools工具类,并发集合
xtzhiker的博客
10-03 246
利用synchronized + CAS, 如果没有出现hash冲突, 使用CAS直接添加数据, 只有出现hash冲突的时候才会使用同步锁添加数据, 又提升了效率, 它底层由"数组"+链表+红黑树的方式思想(JDK8中HashMap的实现)， 为了做到并发，又增加了很多辅助的类，例如TreeBin，Traverser等对象内部类。​ 通俗的理解是当我们往一个容器添加元素的时候，不直接往当前容器添加，而是先将当前容器进行Copy，复制出一个新的容器，然后往新的容器里添加元素。
JDK源码阅读（九）：JUC之并发集合
遇卿
04-16 295
文章目录非阻塞队列ConcurrentHashMap实现原理ConcurrentSkipListMapConcurrentSkipListSetConcurrentLinkedQueueConcurrentLinkedDequeCopyOnWriteArrayListCopyOnWriteArraySet阻塞队列ArrayBlockingQueueLinkedBlockingQueueoffer(...
Java并发编程：掌握JUC并发工具类
"Java并发编程的核心在于理解和运用各种并发工具类，这些工具能够帮助开发者有效地管理和协调多线程的执行，提高程序的并发性能。本文将探讨Java并发包（JUC）中的几个关键工具类，包括CountDownLatch、...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值