第六章 Concurrent Collections (并发集合类) 【上】

最新推荐文章于 2025-07-30 07:17:12 发布
最新推荐文章于 2025-07-30 07:17:12 发布
阅读量1.6k 收藏 1
点赞数
CC 4.0 BY-SA版权
分类专栏： Java 7 Concurrency Cookbook 文章标签： 多线程 DeleyQueue PriorityBlockingQueu LinkedBlockingDeque ConcurrentLinkedDequ
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/m0_37355951/article/details/77409409
本文深入探讨Java中的并发集合类，包括非阻塞和阻塞线程安全的List集合、通过优先级确定顺序的阻塞式线程安全List集合、通过延迟元素实现的线程安全List集合等。通过具体实例讲解各种集合类的特点及应用场景。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

本章涉及内容：

  • 使用非阻塞、线程安全lists集合
  • 使用阻塞、线程安全lists集合
  • 通过优先级确定顺序来使用阻塞式线程安全lists集合
  • 通过延迟元素来使用线程安全lists集合
  • 使用线程安全导航maps集合
  • 生成一个并发随机数
  • 使用原子变量
  • 使用原子数组

简介

数据结构是程序最基础的元素。Java API提供java 集合框架来管理数据，当你在选择集合类要特别小心，有些集合类并不支持并发功能，这样会导致数据不一致情况，例如是ArrayList类。

java也提供并发集合类框架，它大致可以分为两种并发类

阻塞集合： 没有取到元素会一直阻塞。

非阻塞集合： 没有获取到元素会立即返回null值或抛出一个异常。线程不会阻塞。

这章会涉及的类：

  1. 非阻塞list集合，使用ConcurrentLinkedDeque类实现
  2. 阻塞list集合，使用LinkedBlockingDeque类实现
  3. 阻塞list集合来实现生产者和消费者模型。使用LinkedTransferQueue类实现
  4. 通过延迟元素来实现阻塞list集合，使用DelayQueue类
  5. 非阻塞导航map，使用ConcurrentSkipListMap 类
  6. 随机数，使用ThreadLocalRandom类
  7. 原子变量和数组，使用AtomicLong和AtomicIntegerArray类

1、使用非阻塞式线程安全的list集合

ConcurrentLinkedDeque类

package com.jack;

import java.util.concurrent.ConcurrentLinkedDeque;

public class AddTask implements Runnable{

	private ConcurrentLinkedDeque<String> list;
	
	public AddTask(ConcurrentLinkedDeque<String> list) {
		super();
		this.list = list;
	}

	@Override
	public void run() {
		String name = Thread.currentThread().getName();
		for (int i=0; i<10000; i++){
			list.add(name+ " : Element " + i);
		}
	}

}


package com.jack;

import java.util.concurrent.ConcurrentLinkedDeque;

public class PollTask implements Runnable{

	private ConcurrentLinkedDeque<String> list;
	
	public PollTask(ConcurrentLinkedDeque<String> list) {
		super();
		this.list = list;
	}
	
	@Override
	public void run() {
		for (int i=0; i<5000; i++){
			list.pollFirst();
			list.pollLast();
		}
		
	}

}

package com.jack;

import java.util.concurrent.ConcurrentLinkedDeque;

public class Main {
	public static void main(String[] args) {
		ConcurrentLinkedDeque<String> list = new ConcurrentLinkedDeque<>();
		
		Thread threads[] = new Thread[100];
		for (int i=0; i<threads.length ; i++){
			AddTask task = new AddTask(list);
			threads[i] = new Thread(task);
			threads[i].start();
		}
		System.out.printf("Main : %d AddTask 线程已经启动了\n", threads.length);
		for (int i=0; i<threads.length; i++){
			try {
				threads[i].join();
			} catch (InterruptedException e){
				e.printStackTrace();
			}
		}
		System.out.printf("Main： List大小 ： %d\n", list.size());
		for(int i=0; i< threads.length; i++){
			PollTask task = new PollTask(list);
			threads[i] = new Thread(task);
			threads[i].start();
		}
		System.out.printf("Main： %d PollTask 线程已经启动了\n", threads.length);
		for (int i=0; i<threads.length; i++){
			try {
				threads[i].join();
			} catch (InterruptedException e){
				e.printStackTrace();
			}
		}
		System.out.printf("Main : 大小集合： %d\n", list.size());
	}
}

日志： 

Main : 100 AddTask 线程已经启动了
Main： List大小 ： 1000000
Main： 100 PollTask 线程已经启动了
Main : 大小集合： 0

  • 总结：
  • 1、pollFirst移除第一个元素
  • 2、pollLast移除最后一个元素

扩展

  • 1、getFirst() 和getLast() 获取第一个元素和最后一个元素，并不会把元素移除，如果list集合为空，这个方法将会抛出NoSuchElementException异常。
  • 2、peek()，peekFirst() 和peekLast() 返回一个元素和最后一个元素。但是不会移除元素。如果集合为空，返回null值。
  • 3、remove()，removeFirst(), removeLast() 返回第一个元素和最后一个元素，会移除元素，如果为空，将会抛出NoSuchElementException异常。

2、使用阻塞线程安全的list集合

使用LinkedBlockingDeque实现阻塞list集合

package com.jack;

import java.util.Date;
import java.util.concurrent.LinkedBlockingDeque;
import java.util.concurrent.TimeUnit;

public class Client implements Runnable{

	private LinkedBlockingDeque<String> requestList;
	
	public Client(LinkedBlockingDeque<String> requestList) {
		super();
		this.requestList = requestList;
	}

	@Override
	public void run() {
		for (int i=0; i<3; i++){
			for (int j=0; j<5; j++){
				StringBuilder request = new StringBuilder();
				request.append("[" + i);
				request.append(",");
				request.append(j +"]");
				try {
					requestList.put(request.toString());
				} catch (InterruptedException e){
					e.printStackTrace();
				}
				System.out.printf("客户端==添加的元素为%s  日期： %s.\n", request, new Date());
			}
			try{
				TimeUnit.SECONDS.sleep(2);
			} catch (InterruptedException e){
				e.printStackTrace();
			}
		}
		System.out.printf("客户端: 执行完毕. \n");
		
	}

}


总结：

1、创建一个LinkedBlockingDeque集合。

2、往里面添加元素 put() 如果有集合有大小限制，当它满了时候会阻塞

package com.jack;

import java.util.Date;
import java.util.concurrent.LinkedBlockingDeque;
import java.util.concurrent.TimeUnit;

public class Main {
	public static void main(String[] args) throws Exception{
		LinkedBlockingDeque<String> list = new LinkedBlockingDeque<>(3);
		Client client = new Client(list);
		Thread thread = new Thread(client);
		thread.start();
		for (int i=0; i<5; i++){
			for(int j=0; j<3; j++){
				String request = list.take();
				System.out.printf("Main: 拿出元素为 : %s 日期为： %s.  当前集合的大小: %d\n", request, new Date(), list.size());
			}
			TimeUnit.MILLISECONDS.sleep(300);
		}
		System.out.printf("Main : 执行完毕.\n");
	}
}


总结：

  • 1、开启一个线程来向list集合添加元素
  • 2、主线程循环来获取元素take()方法，如果集合没有元素，那么它会有一直阻塞。

扩展：

  • 1、takeFirst() 和takeLast() 返回第一个和最后一个元素，同时会移除元素，如果集合为空，它会一直阻塞
  • 2、getFirst() 和getLast()  返回第一个和最后一个元素，不会移除元素，如果集合为空，它将会抛出NoSuchElementException异常。
  • 3、peek(), peekFirst(),和peekLast() 返回第一个和最后一个元素，不会移除元素，如果集合为空，它将返回null值
  • 4、poll(), pollFirst() 和pollLast()  返回第一个和最后一个元素，同时会移除元素，如果集合为空，它会返回null值
  • 5、add(), addFist()和addLast() 向第一个或最后一个位置添加元素，如果集合满了将会抛出IllegalStateException异常。

日志：


3、通过优先级使用阻塞线程安全有序list集合

通过PriorityBlockingQueue进行实现

package com.jack;

public class Event implements Comparable<Event> {

	private int thread;
	private int priority;
	
	public Event(int thread, int priority) {
		super();
		this.thread = thread;
		this.priority = priority;
	}

	public int getThread() {
		return thread;
	}

	public int getPriority() {
		return priority;
	}

	@Override
	public int compareTo(Event o) {
		if(this.priority>o.getPriority()){
			return -1;
		} else if(this.priority<o.getPriority()){
			return 1;
		}else{
			return 0;
		}
	}

	
}

总结：创建一个Event实现Comparable接口，根据Priority进行比较 

package com.jack;

import java.util.concurrent.PriorityBlockingQueue;

public class Task implements Runnable {

	private int id;
	private PriorityBlockingQueue<Event> queue;
	
	public Task(int id, PriorityBlockingQueue<Event> queue) {
		super();
		this.id = id;
		this.queue = queue;
	}

	@Override
	public void run() {
		for (int i=0; i<1000; i++){
			Event event = new Event(id,i);
			queue.add(event);
		}
	}
	

}

总结：创建一个PriorityBlockingQueue来添加元素，注意事件需要实现Comparable接口 

package com.jack;

import java.util.concurrent.PriorityBlockingQueue;

public class Main {
	public static void main(String[] args) throws Exception{
		PriorityBlockingQueue<Event> queue = new PriorityBlockingQueue<>();
		Thread taskThreads[] = new Thread[5];
		for (int i=0; i<taskThreads.length; i++){
			Task task = new Task(i, queue);
			taskThreads[i] = new Thread(task);
		}
		for (int i=0; i<taskThreads.length; i++){
			taskThreads[i].start();
		}
		
		for (int i=0; i<taskThreads.length;i++){
			try{
				taskThreads[i].join();
			}catch (InterruptedException e){
				e.printStackTrace();
			}
		}
		System.out.printf("Main: 队列的大小： %d\n", queue.size());
		for(int i=0; i<taskThreads.length*1000; i++){
			Event event = queue.poll();
			System.out.printf("线程 %s: 优先级 %d\n", event.getThread(), event.getPriority(), event);
			
		}
		System.out.printf("Main : 队列大小： %d\n", queue.size());
		System.out.printf("Main: 执行完毕了");
	}
}

总结：

  • 1、创建5个线程来执行添加任务
  • 2、taskThreads[i].join()表示等待所有线程添加任务完成之后进行后面的内容
  • 3、打印结果，会发现按照优先级继续排序。

扩展：

  • 1、clear() 移除队列所有元素
  • 2、take() 返回和移除第一个元素，如果队列中没有元素会一直阻塞
  • 3、put(E e) 插入一个元素
  • 4、peek()： 它会返回第一个元素，而不会移除它。

日志：



4、使用延迟来实现线程安全list集合

利用DelayedQueue类来实现延迟执行，但是必须要实现两个方法

compareTo(Delayed o): Delayed接口继承了Comparable接口

getDelay(TimeUnit unit) : 返回激活的延迟的时间

package com.jack;

import java.util.Date;
import java.util.concurrent.Delayed;
import java.util.concurrent.TimeUnit;

public class Event implements Delayed {

	private Date startDate;
	
	public Event(Date startDate) {
		super();
		this.startDate = startDate;
	}

	@Override
	public int compareTo(Delayed o) {
		long result = this.getDelay(TimeUnit.NANOSECONDS) - o.getDelay(TimeUnit.NANOSECONDS);
		if(result <0){
			return -1;
		} else if(result>0){
			return 1;
		}
		return 0;
	}

	@Override
	public long getDelay(TimeUnit unit) {
		Date now = new Date();
		long diff = startDate.getTime() - now.getTime();
		return unit.convert(diff, TimeUnit.MILLISECONDS);
	}

	

	
}

总结：

  • 1、这个Event实现接口 Delayed,然后实现两个方法 compareTo方法和getDelay()方法
  • 2、以开始时间-当前时间得到延迟时间，最后将延迟时间转成对应的单位covert(diff, TimeUnit.MiLLISECONDS) diff延迟时间的数值，第二个参数是延迟的单位，unit本身单位是转换的目标单位（TimeUnit.NANOSECONDS）。

package com.jack;

import java.util.Date;
import java.util.concurrent.DelayQueue;

public class Task implements Runnable {

	private int id;
	private DelayQueue<Event> queue;
	
	
	public Task(int id, DelayQueue<Event> queue) {
		super();
		this.id = id;
		this.queue = queue;
	}


	@Override
	public void run() {
		Date now = new Date();
		Date delay = new Date();
		delay.setTime(now.getTime() + (id*1000));
		System.out.printf("线程 %s 延迟了%s\n", id, delay);
		for (int i=0; i<100; i++){
			Event event = new Event(delay);
			queue.add(event);
		}
	}
	

}

总结：主要设置延迟的时间为1秒，然后将它加入队列中。 

package com.jack;

import java.util.Date;
import java.util.concurrent.DelayQueue;
import java.util.concurrent.TimeUnit;

public class Main {
	public static void main(String[] args) throws Exception{
		DelayQueue<Event> queue = new DelayQueue<>();
		Thread threads[] = new Thread[5];
		for(int i=0; i<threads.length; i++){
			Task task = new Task(i+1, queue);
			threads[i] = new Thread(task);
		}
		for(int i=0; i<threads.length; i++){
			threads[i].start();
		}
		for(int i=0; i<threads.length; i++){
			threads[i].join();
		}
		do{
			int counter =0;
			Event event;
			do{
				event = queue.poll();
				if(event != null){
					counter++;
				}
			}while (event !=null);
			System.out.printf("日期：%s 已经读取 %d 事件\n", new Date(), counter);
			TimeUnit.MILLISECONDS.sleep(500);
		}while (queue.size() >0);
	}
}

总结：

  • 1、创建5个线程代表5个延迟任务。
  • 2、开始获取任务，判断获取任务时间是否为延迟之后的时间。

扩展：

  • 1、注意Queue.size()方法返回数量包含活动和非活动的元素
  • 2、clear() : 移除所有元素
  • 3、offer(E e) :插入一个元素
  • 4、peek(): 返回一个元素而不移除元素
  • 5、take() 返回元素并且移除元素。如果队列为空，线程会阻塞到有元素为止。

日志：

线程 5 延迟了Sat Aug 19 16:25:51 CST 2017
线程 3 延迟了Sat Aug 19 16:25:49 CST 2017
线程 4 延迟了Sat Aug 19 16:25:50 CST 2017
线程 1 延迟了Sat Aug 19 16:25:47 CST 2017
线程 2 延迟了Sat Aug 19 16:25:48 CST 2017
日期：Sat Aug 19 16:25:46 CST 2017 已经读取 0 事件
日期：Sat Aug 19 16:25:47 CST 2017 已经读取 0 事件
日期：Sat Aug 19 16:25:47 CST 2017 已经读取 100 事件
日期：Sat Aug 19 16:25:48 CST 2017 已经读取 0 事件
日期：Sat Aug 19 16:25:48 CST 2017 已经读取 100 事件
日期：Sat Aug 19 16:25:49 CST 2017 已经读取 0 事件
日期：Sat Aug 19 16:25:49 CST 2017 已经读取 100 事件
日期：Sat Aug 19 16:25:50 CST 2017 已经读取 0 事件
日期：Sat Aug 19 16:25:50 CST 2017 已经读取 100 事件
日期：Sat Aug 19 16:25:51 CST 2017 已经读取 0 事件
日期：Sat Aug 19 16:25:51 CST 2017 已经读取 100 事件

C#并发集合实战：深入剖析ConcurrentBag与ConcurrentQueue的特性和应用场景
java专栏
04-24 2492
是一个线程安全的无序集合，允许多个生产者线程同时向其中添加元素，多个消费者线程同时从中取出元素。通过使用这些并发集合类，开发者可以在编写多线程程序时避免手动管理锁，简化代码并提高程序的并发性能与稳定性。等，它们专为多线程环境设计，提供线程安全的操作。以下将详细探讨这两个并发集合类的特性和使用方法，并通过代码示例与注释进行演示。是一个线程安全的先进先出（FIFO）队列，允许多线程并发地进行入队（Enqueue）和出队（TryDequeue）操作。在多线程编程中，传统的非线程安全集合类（如。
JUC并发编程第十四章——线程安全集合类
qq_64064246的博客
06-19 946
重点介绍 java.util.concurrent.* 下的线程安全集合类，可以发现它们有规律，里面遍历时如果发生了修改，对于非安全容器来讲，使用机制也就是让遍历立刻失败，抛出ConcurrentModifificationException，不再继续遍历。
ConcurrentList
03-07
并发列表 一个简单的基于锁的线程安全List <T>实现。 这类似于 。 枚举列表时（例如在foreach循环中），将使用列表的副本进行枚举。 这样可以防止“修改集合”错误，但是也意味着列表在枚举过程中可能不是最新的。 由于它会复制整个列表，因此也可能导致过多的内存使用。 谨慎枚举。 在大多数情况下，您可以使用线程安全的ForAsync和ForEachAsync方法。 但是，您不能从这些循环中直接访问ConcurrentList<T>其他成员。 若要从ForAsync或ForEacAsync循环中更改ConcurrentList<T> ，请使用QueueAction方法。 这将使将在循环完成之后但在释放列表上的锁之前执行的操作排队。
Concurrent Collections 并发集合
luccs624061082的专栏
06-08 223
java.util.concurrent包 包含了大量Java 集合框架的补充。这些是最容易分类的，通过接口集合提供： 1 BlockingQueue 阻塞队列 定义了一个先进先出的数据结构，当试图添加进一个满的队列或者从一个空的队列中获取时会阻塞或者超时。 2 ConcurrentMap 并发隐射 java.util.Map的子接口定义了有用的原子操作。这些操作移除或替...
线程安全集合 --- Concurrent
weixin_37069383的博客
05-18 38
那先来看一下该库都有哪些成员从微软官方文档看一下[1]的介绍:：为实现了IProducerConsumerCollection接口的集合提供阻塞和限制功能，可用于生产者 - 消费者场景。：无序的、线程安全的集合，适合于生产者 - 消费者模式，允许快速添加和移除元素。：线程安全的键值对集合，支持多个线程同时读写操作，避免了锁竞争带来的性能问题。：线程安全的先进先出（FIFO）队列，支持多个线程同时入队和出队操作。：线程安全的后进先出（LIFO）栈，支持多个线程同时入栈和出栈操作。
并发集合（Concurrent Collections）是Java提供的一种在多线程环境中使用数据集合的方式
BLOG域名:programb.blog.youkuaiyun.com
12-09 1000
并发集合（Concurrent Collections）是Java提供的一种在多线程环境中使用数据集合的方式。它们通过提供线程安全的方式来避免数据竞争和线程阻塞。
Concurrent 并发集合
weixin_62587914的博客
07-17 920
线程安全带并发集合
第六章 Concurrent Collections (并发集合类) 【下】
往前的娘娘
08-19 504
本章涉及内容： 使用非阻塞、线程安全lists集合使用阻塞、线程安全lists集合通过优先级确定顺序来使用阻塞式线程安全lists集合通过延迟元素来使用线程安全lists集合使用线程安全导航maps集合生成一个并发随机数使用原子变量使用原子数组 1、使用线程安全导航maps集合 ConcurrentSkipListMap 实现了ConcurrentNavigableMap接口，它使用了S
深入剖析Java并发容器与算法: ConcurrentMap vs. HashTable及常用集合类解析 面试 面经 算法 数据结构
03-20
内容概要：本文详细探讨了Java并发环境下的ConcurrentHashMap与HashTable的关键差异，介绍了LinkedHashMap、HashMap及其与Set类家族成员的异同，并分析了诸如Collections.sort等重要工具方法的工作机制。此外，文档...
在 C# 中，System.Collections.Concurrent 命名空间提供了线程安全的集合类，适用于多线程并发场景
最新发布
zhxup606的专栏
07-30 789
以下是对 System.Collections.Concurrent 中常用工具的详细讲解，包括其功能、用法、完整代码示例和测试用例。在 C# 中，System.Collections.Concurrent 命名空间提供了线程安全的集合类，适用于多线程并发场景。2. 代码示例以下是一个完整的代码示例，展示如何使用上述并发集合类，并附带测试用例。如果需要更深入的某一集合用法或特定场景的优化，请告诉我，我可以进一步扩展！
java并发集合
04-12
Java提供了一系列的并发集合类，使得在并发环境中实现高效且线程安全的数据处理成为可能。这些集合主要存在于`java.util.concurrent`包中，设计目标是提高并发性能并减少同步开销。 首先，我们要了解Java并发集合的...
Java 理论与实践: 并发集合类
02-25 430
DougLea的 util.concurrent 包除了包含许多其他有用的并发构造块之外，还包含了一些主要集合类型 List 和 Map 的高性能的、线程安全的实现。在本月的 Java理论与实践中，BrianGoetz向您展示了用 ConcurrentHashMap 替换 Hashtable 或 synchronizedMap ，将有多少并发程序获益。您可以在本文的 论坛中与作者以及其他读者共享您
java多线程——concurrentList
台风天赋的博客
08-08 1万+
java中的List类型中，只有CopyOnWriteArrayList是线程安全的ArrayList。 在copyOnWriteList中，基本底层还是不变：由数组构成的链表，有一个Object[]数组域。 但是在其内部有一个ReentrantLock独占锁，在增删改的时候都是先上锁再操作。 所以它是并发安全的。 ① 在实现的时候，都是先先将数组域复制到一个新数组中，然后对这个新数组进行增删改，最后将新数组赋给旧数组。 ② 在进行迭代iterator时，实际上是对内部数组域快照的一个迭代，如果这个数组域
\(^_^)/ Java中的并发集合(Concurrent Collections)
yanguz的专栏
04-10 254
    并发集合：   用于多线程上下文中的 Collection 实现：ConcurrentHashMap、ConcurrentSkipListMap、ConcurrentSkipListSet、CopyOnWriteArrayList 和 CopyOnWriteArraySet。 当期望许多线程访问一个给定 collection 时，ConcurrentHashMap 通常优于同步...
8.1并发集合（Concurrent Collections）
owen_william的博客
01-29 494
Java并发框架在包java.util.package中提供了接口和类。接口中包含List、Set和Map；类包含了ArrayList、TreeSet和HashMap。       ArrayList、TreeSet、HashMap和其它的类都继承了这些类接口，但是它们是不安全的线程。然而，你可以让它们在使用是安全的线程，通过使用java.util.Collection类的同步擦除方法。例如
java.util.concurrent——collection
苏北讲道理给你听
05-21 391
一、前言 　　完成了JUC的锁框架的分析后，现在分析JUC集合框架，之前分析过的集合框架，很大程度上都不是线程安全的，其在多线程环境下会出现很多问题，为了保证在多线程环境下仍然能够正确安全的访问集合，出现了JUC下的集合框架，下面逐一进行介绍分析。 二、JUC集合框架图 　　下面给出JUC中的集合框架，之后我们会对其中的类进行详细的分析。 说明：由上图可以看到，JUC的集合框架也是从M...
java多线程之路之线程安全的集合—Core Java学习
06-09 649
qqq
基本功：ConcurrentArrayList
热门推荐
布道
05-08 1万+
很多时候，如何保障你的代码高并发高性能，这的确是个很耐人寻味的话题。高性能意味着你要对采用的每一个容器、集合（数据结构）要非常讲究，而它往往是很多人不太注意的地方，这也行就是你不能专家级的一方面原因！so，基本功很重要，尽可能的接触底层实现。在java圈中，ArrayList 是非线程安全的，难道在多线程场景下我们只有Vector这一种线程安全的数组实现可以选择么？ 当然也有List sync...
Java理论与实践：并发集合类——ConcurrentHashMap与CopyOnWriteArrayList
此系列文章的第一部分着重介绍了两个关键的并发集合类：`ConcurrentHashMap`和`CopyOnWriteArrayList`。 1. **有条件的线程安全性**： 线程安全意味着在一个多线程环境中，对象的状态在被多个线程访问时仍然保持...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值