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

最新推荐文章于 2023-12-09 12:53:29 发布
最新推荐文章于 2023-12-09 12:53:29 发布
阅读量447 收藏
点赞数
分类专栏： Java 7 Concurrency Cookbook 文章标签： 多线程 AtomicLong ThreadLocalRandom ConcurrentSkipListMa 并发集合
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_37355951/article/details/77413790
版权
本章涉及内容：
  • 使用非阻塞、线程安全lists集合
  • 使用阻塞、线程安全lists集合
  • 通过优先级确定顺序来使用阻塞式线程安全lists集合
  • 通过延迟元素来使用线程安全lists集合
  • 使用线程安全导航maps集合
  • 生成一个并发随机数
  • 使用原子变量
  • 使用原子数组

1、使用线程安全导航maps集合

ConcurrentSkipListMap 实现了ConcurrentNavigableMap接口，它使用了Skip List 数据结构（基于平行list集合）来存储数据，使得存储更加高效。

例子：利用ConcurrentSkipListMap实现联系人

package com.jack;

public class Contact {
	private String name;
	private String phone;
	public Contact(String name, String phone) {
		super();
		this.name = name;
		this.phone = phone;
	}
	public String getName() {
		return name;
	}
	public String getPhone() {
		return phone;
	}

	
}

总结：创建一个联系人实体类，姓名和电话号码 

package com.jack;

import java.util.concurrent.ConcurrentSkipListMap;

public class Task implements Runnable {

	private String id;
	private ConcurrentSkipListMap<String, Contact> map;
	
	public Task(String id, ConcurrentSkipListMap<String, Contact> map) {
		super();
		this.id = id;
		this.map = map;
	}

	@Override
	public void run() {
		for (int i=0; i<1000; i++){
			Contact contact =new Contact(id, String.valueOf(i+1000));
			map.put(id+contact.getPhone(), contact);
		}
	}
	
	
	
	

}

总结：创建一个ConcurrentSkipListMap<String,Contact>来保存联系人，键为姓名+电话号码 

package com.jack;

import java.util.Map;
import java.util.concurrent.ConcurrentNavigableMap;
import java.util.concurrent.ConcurrentSkipListMap;

public class Main {
	public static void main(String[] args) throws Exception{
		ConcurrentSkipListMap<String, Contact> map;
		map = new ConcurrentSkipListMap<>();
		Thread threads[] = new Thread[25];
		int counter =0;
		for (char i='A'; i<'Z'; i++){
			Task task = new Task(String.valueOf(i),map);
			threads[counter] = new Thread(task);
			threads[counter].start();
			counter++;
		}
		for (int i=0; i<25; i++){
			try{
				threads[i].join();
			} catch(InterruptedException e){
				e.printStackTrace();
			}
		}
		System.out.printf("Main: map的大小：%d\n", map.size());
		Map.Entry<String, Contact> element;
		Contact contact;
		
		element = map.firstEntry();
		contact = element.getValue();
		System.out.printf("Main: 第一个Entry ： %s: %s\n", contact.getName(), contact.getPhone());
		element = map.lastEntry();
		contact = element.getValue();
		System.out.printf("Main: 最后的Entry: %s： %s\n", contact.getName(), contact.getPhone());
		System.out.printf("Main: 子map从A1996 到B1002： \n");
		ConcurrentNavigableMap<String, Contact> submap = map.subMap("A1996", "B1002");
		do{
			element=submap.pollFirstEntry();
			if(element!=null){
				contact = element.getValue();
				System.out.printf("%s: %s\n", contact.getName(), contact.getPhone());
			}
			
		}while (element !=null);
	}
}

总结：

  • 1、创建一个ConcurrentSkipListMap 实例
  • 2、创建25个线程来添加联系人
  • 3、threads[i].join()方法防止main提前退出
  • 4、map.firstEntry() 得到第一个键值对，map.lastEntry()得到最后键值对
  • 5、map.subMap得到一个子map，两个参数是键的范围。主要A1000 到A1999 一直到Y1000到Y1999
  • 6、pollFirstEntry() 得到第一个键值对，同时移除。
  • 7、这里亮点就是它会按照A1000 到Y1999顺序排列

 扩展：

  • 1、headMap(K toKey) 返回该toKey前一个元素。
  • 2、tailMap(K fromKey): 返回该fromKey后一个元素
  • 3、putIfAbsent(K key, V value) ,如果不存在就插入该键值
  • 4、pollLastEntry() 移除最后的键值对（Map.Entry）
  • 5、replace(k key, V value) 如果存在该key进行替换。

2、生成一个并发随机数

通过ThreadLocalRandom类生成随机数 （其实就是线程内部一个随机生成器，不会与其他线程共用生成器）

package com.jack;

import java.util.concurrent.ThreadLocalRandom;

public class TaskLocalRandom implements Runnable {

	
	public TaskLocalRandom() {
		ThreadLocalRandom.current();
	}

	@Override
	public void run() {
		String name = Thread.currentThread().getName();
		for(int i=0; i<10; i++){
			System.out.printf("%s: %d\n", name, ThreadLocalRandom.current().nextInt());
		}
		
	}

}


package com.jack;

public class Main {
	public static void main(String[] args) throws Exception{
		Thread threads[] = new Thread[3];
		for (int i=0; i<3; i++){
			TaskLocalRandom task = new TaskLocalRandom();
			threads[i] = new Thread(task);
			threads[i].start();
		}
	}
}


总结：基本用法和Math.random类似
日志： 
Thread-0: -1183906547
Thread-0: 577959842
Thread-0: -105441313
Thread-0: -425609536
Thread-0: 1551546221
Thread-0: 191950995
Thread-0: -915467104
Thread-0: 1952188497
Thread-0: 845863336
Thread-0: 888400078
Thread-1: 1682302533
Thread-1: 1007563307
Thread-1: -1911050677

3、使用原子变量

原子变量基于同步思想Compare and Set(比较和设置)，简单理解就是判断旧的值是否不变，那么就可以进行设置操作，如果旧的值改变就进行下次相同的操作，直到完成测试。（大概不恰当的比喻，早晨上厕所，人很多需要等，当然你可以不用等，先玩一会，等5分钟然后在看一次有没有占住厕所，如果没有你可以去，如果有你会宿舍玩一会再来看。。。）

例子：利用AtomicLong来模拟取存款过程

package com.jack;

import java.util.concurrent.atomic.AtomicLong;

public class Account {

	private AtomicLong balance;

	public Account() {
		super();
		balance = new AtomicLong();
	}

	public AtomicLong getBalance() {
		return balance;
	}

	public void setBalance(AtomicLong balance) {
		this.balance = balance;
	}
	
	public void addAmount(long amount){
		this.balance.getAndAdd(amount);
	}
	
	public void substractAmount(long amount){
		this.balance.getAndAdd(-amount);
	}
	
}

总结：

  • 1、创建一个AtomicLong();
  • 2、增加余额balance.getAndAdd(amount)
  • 3、减少余额balance.getAndAdd(-amount) 

package com.jack;

import java.util.concurrent.atomic.AtomicLong;

public class Account {

	private AtomicLong balance;

	public Account() {
		super();
		balance = new AtomicLong();
	}

	public AtomicLong getBalance() {
		return balance;
	}

	public void setBalance(AtomicLong balance) {
		this.balance = balance;
	}
	
	public void addAmount(long amount){
		this.balance.getAndAdd(amount);
	}
	
	public void substractAmount(long amount){
		this.balance.getAndAdd(-amount);
	}
	
}
总结：存钱 

package com.jack;

public class Bank implements Runnable {

	private Account account;
	
	
	public Bank(Account account) {
		super();
		this.account = account;
	}


	@Override
	public void run() {
		for (int i=0; i<100; i++){
			account.substractAmount(1000);
		}
		
	}
	
}
总结：取钱 

package com.jack;

import java.util.concurrent.atomic.AtomicLong;

public class Main {
	public static void main(String[] args) throws Exception{
		Account account = new Account();
		
		account.setBalance(new AtomicLong(1000));
		Company company = new Company(account);
		Thread companyThread = new Thread(company);
		Bank bank = new Bank(account);
		Thread bankThread = new Thread(bank);
		System.out.printf("Account: 初始化账户余额 %s\n", account.getBalance().toString());
		companyThread.start();
		bankThread.start();
		try{
			companyThread.join();
			bankThread.join();
			System.out.printf("Account: 最后的余额为： %s\n", account.getBalance().toString());
		}catch (InterruptedException e){
			e.printStackTrace();
		}
	}
}


总结：

  • 1、创建两个线程跑存钱和取钱

扩展：除了AtomicLong， 还有AtomicBoolean, AtomicInteger 和 AtomicReference


4、使用原子数组

当一个对象在多个线程之间共享会可能会导致死锁情况。那么如何避免这个种情况，它提供compare-and-swap operation(比较和交换操作)，它的性能更高，它在修改一个变量值通过如下三步：

  • 1、获取旧的值
  • 2、把新的值赋值给临时变量
  • 3、如果旧的值等于实际变量的值，就可以将新的值进行替换了，反之，说明有其他线程替换值，不能执行替换操作。

例子：使用AtomicIntegerArray类实现

package com.jack;

import java.util.concurrent.atomic.AtomicIntegerArray;

public class Incrementer implements Runnable {

	private AtomicIntegerArray vector;
	
	public Incrementer(AtomicIntegerArray vector) {
		super();
		this.vector = vector;
	}

	@Override
	public void run() {
		for(int i=0; i<vector.length(); i++){
			//在索引i的值自加1
			vector.getAndIncrement(i);
		}
	}

}

package com.jack;

import java.util.concurrent.atomic.AtomicIntegerArray;

public class Decrementer implements Runnable {

	private AtomicIntegerArray vector;
	
	public Decrementer(AtomicIntegerArray vector) {
		super();
		this.vector = vector;
	}

	@Override
	public void run() {
		for(int i=0; i<vector.length(); i++){
			//在索引i的值自减1
			vector.getAndDecrement(i);
		}
		
	}

}


package com.jack;

import java.util.concurrent.atomic.AtomicIntegerArray;

public class Main {
	public static void main(String[] args) throws Exception{
		final int THREADS = 100;
		AtomicIntegerArray vector = new AtomicIntegerArray(1000);
		Incrementer incrementer = new Incrementer(vector);
		Decrementer decrementer = new Decrementer(vector);
		Thread threadIncrementer[] = new Thread[THREADS];
		Thread threadDecrementer[] = new Thread[THREADS];
		for (int i=0; i<THREADS; i++){
			threadIncrementer[i] = new Thread(incrementer);
			threadDecrementer[i] = new Thread(decrementer);
			threadIncrementer[i].start();
			threadDecrementer[i].start();
		}
		for(int i=0; i<100; i++){
			try {
				threadIncrementer[i].join();
				threadDecrementer[i].join();
			} catch (InterruptedException e){
				e.printStackTrace();
			}
		}
		for (int i = 0; i < vector.length(); i++) {
			if(vector.get(i) !=0){
				System.out.printf("Main: Vector[ %d ] : %d\n", i, vector.get(i));
			}
		}
		System.out.println("Main:执行结束");
	}
}

总结：

  • 1、创建容量为1000的数组AtomicIntegerArray.
  • 2、创建两个增加和减少任务 （每种任务总共跑100个线程）
  • 3、join()方法防止main提前退出
  • 4、判断数组的值是否为0，正确的应该是0（如果你想看到不为零效果可以注释减任务获取加任务）

扩展：

  • 1、get(int i) 返回索引为i的数据
  • 2、set(int I, int newValue) 设置索引i的值

日志：

Main:执行结束

第六章完。。。。。。。。。。。。。

往前的
关注
专栏目录
C#并发集合实战：深入剖析ConcurrentBag与ConcurrentQueue的特性和应用场景
java专栏
04-24 1869
是一个线程安全的无序集合，允许多个生产者线程同时向其中添加元素，多个消费者线程同时从中取出元素。通过使用这些并发集合类，开发者可以在编写多线程程序时避免手动管理锁，简化代码并提高程序的并发性能与稳定性。等，它们专为多线程环境设计，提供线程安全的操作。以下将详细探讨这两个并发集合类的特性和使用方法，并通过代码示例与注释进行演示。是一个线程安全的先进先出（FIFO）队列，允许多线程并发地进行入队（Enqueue）和出队（TryDequeue）操作。在多线程编程中，传统的非线程安全集合类（如。
集合类并发不安全问题
酷小亚
06-11 122
代码如下： 代码如下： 总结如下： 1、 CopyOnWrite 由于使用了 “写时复制” 的思想，适用于 “读多写少” 的场景； 由于在进行写操作的时候会复制原数组，对内存的占用会比较大，不适用于大数据量的场景； 只能保证最终的数据一致性，不能保证实时的数据一致性——读操作只能从旧数组中读取数据，而此时可能已经复制了一个新数组，并且正在修改新数组的数据。 迭代是对快照进行的，不会抛出 ，且迭代过程中不支持修改操作。1、线程不安全的HashMap2、效率低下的HashTable容器3、Concurre
Concurrent Collections 并发集合
luccs624061082的专栏
06-08 184
java.util.concurrent包 包含了大量Java 集合框架的补充。这些是最容易分类的，通过接口集合提供： 1 BlockingQueue 阻塞队列 定义了一个先进先出的数据结构，当试图添加进一个满的队列或者从一个空的队列中获取时会阻塞或者超时。 2 ConcurrentMap 并发隐射 java.util.Map的子接口定义了有用的原子操作。这些操作移除或替...
第六章 Concurrent Collections (并发集合类) 【上】
往前的娘娘
08-19 1526
本章涉及内容： 使用非阻塞、线程安全lists集合使用阻塞、线程安全lists集合通过优先级确定顺序来使用阻塞式线程安全lists集合通过延迟元素来使用线程安全lists集合使用线程安全导航maps集合生成一个并发随机数使用原子变量使用原子数组 1、简介 数据结构是程序最基础的元素。Java API提供java 集合框架来管理数据，当你在选择集合类要特别小心，有些集合类并不支持并
并发集合（Concurrent Collections）是Java提供的一种在多线程环境中使用数据集合的方式
最新发布
BLOG域名:programb.blog.csdn.net
12-09 932
并发集合（Concurrent Collections）是Java提供的一种在多线程环境中使用数据集合的方式。它们通过提供线程安全的方式来避免数据竞争和线程阻塞。
8.1并发集合（Concurrent Collections）
owen_william的博客
01-29 465
Java并发框架在包java.util.package中提供了接口和类。接口中包含List、Set和Map；类包含了ArrayList、TreeSet和HashMap。       ArrayList、TreeSet、HashMap和其它的类都继承了这些类接口，但是它们是不安全的线程。然而，你可以让它们在使用是安全的线程，通过使用java.util.Collection类的同步擦除方法。例如
\(^_^)/ Java中的并发集合(Concurrent Collections)
yanguz的专栏
04-10 188
    并发集合：   用于多线程上下文中的 Collection 实现：ConcurrentHashMap、ConcurrentSkipListMap、ConcurrentSkipListSet、CopyOnWriteArrayList 和 CopyOnWriteArraySet。 当期望许多线程访问一个给定 collection 时，ConcurrentHashMap 通常优于同步...
java并发集合
04-12
Java提供了一系列的并发集合类，使得在并发环境中实现高效且线程安全的数据处理成为可能。这些集合主要存在于`java.util.concurrent`包中，设计目标是提高并发性能并减少同步开销。 首先，我们要了解Java并发集合的...
从java.util到java.util.concurrent：并发集合设计与优化全解析
Java 并发集合作为 Java 标准库中支持多线程环境的集合类，不仅提供了必要的线程安全保证，还针对并发操作进行了优化，以实现更高的性能和效率。本章将带领读者概览 Java 并发集合的全貌，了解其设计理念、核心特性...
【Java并发集合实战】：Collections工具类同步包装器分析
[【Java并发集合实战】：Collections工具类同步包装器分析](https://crunchify.com/wp-content/uploads/2013/11/Java-Synchronized-Collections-by-Crunchify.png) # 1. Java并发编程基础 在现代软件开发中，多线程...
java-同步集合Concurrent Collections应用
热门推荐
心猿意碼
04-18 1万+
一、传统集合的缺陷 传统的集合，在并发访问的时候，是有问题的。如hashset、hashmap和arrayList，多个线程在对他们取数据、放数据的时候，是有问题的，因为他们是线程不安全的。由于没有控制并发，会导致数据的不一致，引起死循环。 为什么会引起死循环？拿HashMap来看，看一下HashMap的get函数的源代码: public V get(Object key){ i...
Synchronized vs Concurrent Collections（并发集合VS同步集合）
u014308482的博客
11-10 4218
Synchronized vs Concurrent Collections不管是同步集合还是并发集合他们都支持线程安全，他们之间主要的区别体现在性能和可扩展性，还有他们如何实现的线程安全。同步HashMap, Hashtable, HashSet, Vector, ArrayList 相比他们并发的实现（比如：ConcurrentHashMap, CopyOnWriteArrayList, Cop
java面试题，写一个线程安全的List
shalousun的专栏
10-29 2678
1.ArrayList,vector以及LinkedList经常在笔试题中出现，网上也有很多的答案，但是又一次参加笔试时遇到这么一道题 写一个线程安全的List，这种题考查我们对java API的熟悉程度 java API中有一个Collections类，里面封装了一些集合的操作 List list = Collections.synchronizedList(new ArrayList
第四章 Thread Executors(Executors多线程架构)【下】
往前的娘娘
08-16 674
本章涉及内容： 创建一个executor线程创建一个固定大小executor执行executor任务返回一个结果处理多任务和处理第一个结果处理多任务和处理所有结果延迟之后运行executor周期地运行任务的executor在executor取消任务在executor控制任务完成在executor分开task启动和处理结果控制executor的拒绝的任务 1、在executor控制任务完成之
第八章 Testing Concurrent Applications(测试并发应用)【上】
往前的娘娘
08-24 593
本章涉及内容： 监控Lock接口监控Phaser类监控一个Executor框架监控Fork/Join线程池写有效的日志用FindBugs分析并发代码配置Eclipse调试并发代码用MultithreadTC测试并发代码 1、简介 并发测试的不同的是你很难重现之前的错误或者异常。 2、监控Lock接口 package com.jack; import java.util.Co
第二章 Basic Thread Synchronization (基础线程同步) 【上】
往前的娘娘
08-12 530
涉及的内容 同步一个方法同步类中分配一个独立属性在同步代码中使用条件使用Lock锁定代码块同步数据的读写锁修改Lock公平模式在Lock中使用多条件 简介 同步类似就是车过收费站，一杆一车，排队出收费站，不许并行。 对于同步的代码块称为critical section (临界断面) 为了实现这个同步将会介绍两种同步方法： 关键字：synchronizedLock的接
第八章 Testing Concurrent Applications(测试并发应用)【下】
往前的娘娘
08-25 496
本章涉及内容： 监控Lock接口监控Phaser类监控一个Executor框架监控Fork/Join线程池写有效的日志用FindBugs分析并发代码配置Eclipse调试并发代码用MultithreadTC测试并发代码 1、写有效的日志信息 利用java.util.logging包为你并发应用添加日志信息
System.Collections.Concurrent：.NET Framework 4线程安全集合优化与实践
当编写新代码时，强烈推荐使用ConcurrentDictionary和BlockingCollection等并发集合类，特别是当有多线程写入的情况。对于只进行读取的操作，可以选择使用System.Collections.Generic命名空间中的非线程安全类，以...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值