对于 Nacos 的动态配置大家都很熟悉，在此我提出个疑问❓ **如何在 Nacos 配置中定义 Bean 信息且实现动态的添加删除 Bean 呢？** 本文是结合工作中的实践，来讲下在 **动态的可插拔式插件设计** 的实现思路，可结合业务场景动态切换告警信息、短信服务商、动态线程池等等



## Nacos 配置中 Bean 的定义

既然要动态的配置 Bean，那么首先需要在配置中定义好 Bean 的结构，需要哪些属性。接下来我将以班级、学生与学生做的事来讲述代码思路

首先定义班级的属性，其中班级下有一群学生，对应的属性为 `students`，每个学生都会做同一件事，接下来我们会将学生做一些事转换为动态的，可通过Nacos配置进行 **增删改**

```java
@Data
@ConfigurationProperties(prefix = ClassProperties.PREFIX)
public class ClassProperties {

 /**
 * 配置属性的前缀
 */
 public static final String PREFIX = "class";

 /**
 * 属性名
 */
 public static final String STU_PROPERTY_NAME = "class.students";

 /**
 * BeanName Template Name
 */
 public static final String BEANNAME_TEMPLATE = "class.students[%s]";

 /**
 * 班级名称
 */
 private String className;

 /**
 * 年级
 */
 private String gradeName;

 /**
 * 班级学生
 * 
 * key:学号，value:学生信息
 * 
 */
 private Map<String, Student> students;

}
```

学生对象的属性

```java
@Data
@NoArgsConstructor
@AllArgsConstructor
public class Student {
 private String name;
 private Integer age;
 private String sex;
}
```

声明学生所做的事情，本质上来说，这就是我们真实要处理业务场景的逻辑，可自行调整

```java
public interface StudentHandler {
 String doSomething();
}

@Data
public class StudentDoSomethingHandler implements StudentHandler {

 private String key;

 private Student student;

 public StudentDoSomethingHandler(String key, Student student) {
 this.key = key;
 this.student = student;
 }

 @Override
 public String doSomething() {
 // do something
 return "【" + key + "】学生【" + student.getName() + "】，今年【" + student.getAge() + "岁】，性别【" + student.getSex() + "】,开始做点什么了...";
 }
}
````

对象定义完了，来描述下Nacos中的属性, `2025140001` 即为 `Map<String, Student> students` 的key，此为 **唯一标识**，用来进行学生的查找，同时也是 `StudentDoSomethingHandler` 中的属性 `key`，而其下的学生信息对应着对象 `student`。

```yaml
class:
 className: 十四班
 gradeName: 初一
 students:
 2025140001:
 name: 张三
 age: 18
 sex: 男
 2025140002:
 name: 紫馨
 age: 20
 sex: 女
 2025140003:
 name: 狗五松溪
 age: 13
 sex: 男
 2025140004:
 name: 构思
 age: 10
 sex: 未知
```


## 动态的注册Bean对象

定义好属性后，我们需要将配置的Bean信息在项目启动时，注入到Spring容器中，交由Spring容器管理。

核心逻辑为：将定义的 `Map<String, Student> students` 转换成 `StudentDoSomethingHandler` 对象，注入到Spring容器中，其中 BeanName 使用模板 `class.students[%s]` 声明，将 `key` 替换到占位符中，最终定义为 `class.students[2025140001]`,此方式便于随时查找Bean对象，整体实现代码如下

```java
@Component
public class StudentBeanDefinitionRegister implements ImportBeanDefinitionRegistrar, EnvironmentAware {

 /**
 * 班级的属性配置
 */
 private ClassProperties classProperties;


 /**
 * Register bean definitions as necessary based on the given annotation metadata of
 * the importing {@code @Configuration} class.
 * Note that {@link BeanDefinitionRegistryPostProcessor} types may not be
 * registered here, due to lifecycle constraints related to {@code @Configuration}
 * class processing.
 * The default implementation is empty.
 *
 * @param importingClassMetadata annotation metadata of the importing class
 * @param registry current bean definition registry
 */
 @Override
 public void registerBeanDefinitions(AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry) {
 // 配置的学生信息
 Map<String, Student> students = classProperties.getStudents();
 if (!CollectionUtils.isEmpty(students)) {
 // 将配置对象转换成Bean，注册到Spring容器中
 students.forEach((key, student) -> {
 // key:beanName, value:beanDefinition
 registry.registerBeanDefinition(buildBeanName(key), buildBeanDefinition(StudentDoSomethingHandler.class, key, student));
 });
 }
 }

 /**
 * 根据 Environment 中的属性名进行构建
 *
 * 
 * 示例：class.students[...]
 * 
 */
 public String buildBeanName(String key) {
 return String.format(ClassProperties.BEANNAME_TEMPLATE, key);
 }

 /**
 * 构建 BeanDefinition
 *
 * @param clazz 构建 Bean 对象的类型
 * @param constructorArguments Bean 的构造参数
 * @param <T> -
 * @return BeanDefinition
 */
 public static <T> BeanDefinition buildBeanDefinition(Class<T> clazz, Object... constructorArguments) {
 // 定义 BeanDefinition
 BeanDefinition beanDefinition = BeanDefinitionBuilder.rootBeanDefinition(clazz).getBeanDefinition();
 ConstructorArgumentValues constructorArgumentValues = beanDefinition.getConstructorArgumentValues();

 // 构建参数
 for (int i = 0; i < constructorArguments.length; i++) {
 constructorArgumentValues.addIndexedArgumentValue(i, constructorArguments[i]);
 }
 return beanDefinition;
 }

 /**
 * Set the {@code Environment} that this component runs in.
 *
 * @param environment
 */
 @Override
 public void setEnvironment(Environment environment) {
 // 绑定属性
 classProperties = PropertiesBinder.bindProperties(ClassProperties.PREFIX, environment, ClassProperties.class);
 }
}
```


:::tip{title="BeanName 的生成"}
BeanName 的生成各种各样，并没有什么规则，但是有一点需要注意，那就是 **保证唯一性**，上述规则中就是根据 key 进行的生成，即保证了唯一性，同时在后续 **删改** 的过程中,可根据调整的 Nacos 配置属性随时定位到修改前的 Bean 对象进行处理。
:::


:::danger{title="依赖关系破坏"}

若实现过程中，其他的 Bean 引用了被移除的 Bean（简称 `引用 Bean`），可能导致 `NoSuchBeanDefinitionException` 或空指针，我们应该避免此类情况。

如果无法避免的情况下，如果是 **属性变更** 导致的移除，只需要将引用过 **被移除 Bean** 的对象进行缓存，在移除 Bean 的同时，构建新的 Bean，在将引用 Bean 中的属性进行覆盖，或者移除引用 Bean，进行重新添加

如果是纯移除 Bean，其他引用到此移除 Bean 导致产生异常的，那只能通过调整代码来解决了
:::


提供一个 `Environment` 环境属性中转换对象的工具类
```java
public class PropertiesBinder {

 @SneakyThrows
 public static <T> T bindProperties(String prefix, Environment environment, Class<T> clazz) {
 // 构建对象
 T t = clazz.getDeclaredConstructor().newInstance();
 Binder binder = Binder.get(environment);
 Bindable<?> target = Bindable.of(ResolvableType.forClass(clazz)).withExistingValue(t);
 binder.bind(prefix, target);
 return t;
 }
}
```

## Nacos配置修改Bean信息

实现了项目启动时，配置中 Bean 对象的初始化以后，我们接下来实现对配置中 Bean 对象的 **增删改**，来保证Spring容器中构建的对象为最新调整的属性

### Nacos 配置的变更

首先，当Nacos 平台上对配置进行变更时，我们需要做出扩展，触发Bean的动态刷新操作。从源码中可以得知，当配置变更时，客户端的 `RefreshEventListener` 监听器，会监听到 `RefreshEvent` 事件，执行 `ContextRefresher #refresh()` 方法，此方法中调用了内部方法 `refreshEnvironment()`，而这个内部方法将会变更本地的配置，同时将变更的属性提取出来，并且发布了 `EnvironmentChangeEvent` 事件，那我们只需要监听这个事件即可

![image.png](/static/img/04823db0535fb27da66c2d5d3b9e6205.image.webp)

上述逻辑中提取的变更属性有3种操作情况，分别是

1. 修改属性：会记录到变更的属性中，修改哪个属性，则记录哪个，例如修改了某个学生的年龄，则会存在一条变更的属性 `class.students[2025140001].age`
2. 删除属性：同修改属性一样，删除了哪些属性，也会记录哪些属性是变更的属性，例如删除了某个key以及对应的学生，则会将学生的对象都会记录上 `class.students[2025140001].name`、`class.students[2025140001].age`、`class.students[2025140001].sex`
3. 新增属性，同修改删除一样，但凡新增的都会记录到变更的属性中

### Bean 的增删改

监听到Nacos配置的变更后，我们需要从变更的属性中，只需要找出 `ClassProperties #students` 的属性变更，其中配置变更的操作也是3种，分别对应上述的配置变更的3种情况

1. 修改属性：确认对象是否在Spring容器中存在，存在则可能为更新或删除属性，接下来确认变更的属性是否还在 `Environment` 中，如果还在，则为更新
2. 删除属性：如果变更的属性不在`Environment` 中，则视为删除属性
3. 新增属性：Spring容器中不存在此变更的属性对象，则为新增属性

结合上述思路，代码实现如下

```java
@Component
public class StudentConfigChangeListener implements EnvironmentAware, BeanFactoryAware, ApplicationListener<EnvironmentChangeEvent> {

 private DefaultListableBeanFactory beanFactory;

 private Environment environment;

 /**
 * Handle an application event.
 *
 * @param event the event to respond to
 */
 @Override
 public void onApplicationEvent(EnvironmentChangeEvent event) {
 // 将当前符合的信息进行变更，其他变更过滤
 parseBeanName(event.getKeys()).forEach(beanName -> {
 // Environment 中是否还存在 Bean 的属性信息
 boolean isExist = false;
 Field[] fields = Student.class.getDeclaredFields();
 for (int i = 0; i < fields.length && !isExist; i++) {
 if (environment.containsProperty(beanName + "." + fields[i].getName())) {
 isExist = true;
 }
 }

 // 添加 Bean
 if (isExist) {
 registerBean(beanName);
 }
 // 删除 Bean
 else {
 removeBean(beanName);
 }
 });
 }

 /**
 * 从变更的属性中解析出自定义的 BeanName
 */
 public Set<String> parseBeanName(Set<String> keys) {
 return keys.stream().filter(key -> key.startsWith(ClassProperties.STU_PROPERTY_NAME)).map(key -> key.substring(0, key.indexOf("]") + 1)).collect(Collectors.toSet());
 }

 /**
 * 删除 Bean
 */
 public void removeBean(String beanName) {
 try {
 StudentFactory.LOCK.writeLock().lock();
 // 删除 BeanDefinition
 if (beanFactory.containsBeanDefinition(beanName)) {
 beanFactory.removeBeanDefinition(beanName);
 }

 // 销毁单例实例
 if (beanFactory.containsSingleton(beanName)) {
 beanFactory.destroySingleton(beanName);
 }

 // 删除缓存
 StudentFactory.STUDETN_HANDLER.remove(beanName);
 } finally {
 StudentFactory.LOCK.writeLock().unlock();
 }
 }

 /**
 * 添加 Bean
 */
 public void registerBean(String beanName) {
 try {
 StudentFactory.LOCK.writeLock().lock();
 // 当前 Bean存在，则先删除 Bean
 if (beanFactory.containsSingleton(beanName)) {
 removeBean(beanName);
 }

 // 注册 BeanDefinition
 String key = beanName.substring(beanName.indexOf("[") + 1, beanName.indexOf("]"));
 Student student = PropertiesBinder.bindProperties(beanName, environment, Student.class);
 beanFactory.registerBeanDefinition(beanName, StudentBeanDefinitionRegister.buildBeanDefinition(StudentDoSomethingHandler.class, key, student));

 // 添加缓存
 StudentFactory.STUDETN_HANDLER.put(beanName, beanFactory.getBean(beanName, StudentHandler.class));
 } finally {
 StudentFactory.LOCK.writeLock().unlock();
 }
 }

 /**
 * Set the {@code Environment} that this component runs in.
 *
 * @param environment
 */
 @Override
 public void setEnvironment(Environment environment) {
 this.environment = environment;
 }

 @Override
 public void setBeanFactory(BeanFactory beanFactory) throws BeansException {
 this.beanFactory = (DefaultListableBeanFactory) beanFactory;
 }
}
```

:::warning{title="插件设计"}
需要注意的一点，以上的代码为插件的设计，尤其是Spring项目启动时自动注册Bean信息实现的 `ImportBeanDefinitionRegistrar` 接口，只会在自动装配中生效，2.7版本以前需要添加到 `META-INF/spring.factories`, 2.7版本以后添加到 `META-INF/spring/org.springframework.boot.autoconfigure.AutoConfiguration.imports` ，具体实现可以查看 [SpringBoot 自动装配原理的满分解读](/post/16)
:::

:::warning{title="单例 Bean 的生命周期"}
单例 Bean 的实例会被容器缓存，移除定义后需手动销毁实例，可查看 `StudentConfigChangeListener #removeBean` 方法中的代码实现
:::

### 门面调用

构建一个门面方法 `doPlan`,根据指定的学生key（也就是nacos配置中的学号 `2025140001`）来执行一些事情的方法

```java
public class StudentFactory {

 /**
 * 读写锁，保证动态Bean信息的线程安全
 */
 public static final ReadWriteLock LOCK = new ReentrantReadWriteLock();

 /**
 * 每个学生对应的处理器缓存，可用来做一些事情
 *
 * 
 * key -> beanName, 对应的格式为: class.students[...]
 * value -> StudentHandler, 学生对应的处理器对象
 * 
 */
 public static Map<String, StudentHandler> STUDETN_HANDLER = new ConcurrentHashMap<>();

 /**
 * 执行学生的计划
 *
 * @param key 学生的key
 * @return 学生的做一些事的结果
 */
 public static String doPlan(String key) {
 try {
 LOCK.readLock().lock();
 StudentHandler studentHandler = STUDETN_HANDLER.get(String.format(ClassProperties.BEANNAME_TEMPLATE, key));
 Assert.notNull(studentHandler, "StudentHandler is null!");
 return studentHandler.doSomething();
 } finally {
 LOCK.readLock().unlock();
 }
 }
}
```


:::danger{title="并发问题"}
动态修改容器可能引发安全问题，通过可重入读写锁 `ReentrantReadWriteLock` 来确保操作原子性，在添加或删除Bean时使用写锁，在读取动态Bean时使用读锁，依赖读写互斥的特性，来解决并发问题。
:::

### 测试示例

在项目中添加接口进行测试

```java
@RestController
public class TestController {

 /**
 * 获取所有学生
 */
 @GetMapping("/get")
 public Object get() {
 Map<String, StudentHandler> beansOfType = SpringUtil.getBeansOfType(StudentHandler.class);
 return JSON.toJSON(beansOfType);
 }
 
 /**
 * 让某个学生做一些事，例如让百度服务商发短信，或其他服务商发短信
 */
 @GetMapping("/getStudent")
 public String getStudent(String key) {
 return StudentFactory.doPlan(key);
 }
}
```

调整 Nacos 平台上的配置后，以上的Bean对象中也会跟着动态调整，访问 `/get` 接口查看，在更新配置后，刷新接口看内容是否发生变更

![image.png](/static/img/756ac01040b769029da914e380efa759.image.webp)

访问 `/getStudent` 接口，可让不同学生执行某些事情

![image.png](/static/img/69a6a1dcd364e1c6976dedeb0ed356ab.image.webp)


## 插件设计的场景

在工作中，我是以此思路实现了 **告警组件**，结合el表达式，可动态调整告警信息。通过某次技术分享后，同事借鉴此思路实现了动态切换短信服务商，可结合实际的业务场景，自行实现动态的插件

基于 Nacos 配置实现动态Bean的插件设计

你可能对List/Set/Map有了解，那juc包下的容器与队列呢？本文将全面剖析 Java 并发容器体系，涵盖从传统同步容器到现代高性能并发容器的演进，结合代码示例与性能对比，帮助你构建高并发体系知识




## 同步容器（JDK 1.0 - JDK 1.2）

### 核心类与接口

| 类/接口 | 描述 | 线程安全实现方式 |
| --- | --- | --- |
| Vector	| 同步版 ArrayList	| 所有方法用 synchronized| 
| Hashtable	| 同步版 HashMap	| 所有方法用 synchronized| 
| Stack	 | 同步栈（继承 Vector）	| 继承 Vector 的同步 | 
| Collections.synchronizedList(List)	| 包装普通 List 为同步 List	| 内部锁对象同步| 
| Collections.synchronizedMap(Map)	| 包装普通 Map 为同步 Map	| 内部锁对象同步| 
| Collections.synchronizedSet(Set)	| 包装普通 Set 为同步 Set	| 内部锁对象同步| 


### 代码示例：同步容器基本使用

```java
// Vector 使用示例
Vector<String> vector = new Vector<>();
vector.add("item1");
vector.remove(0);

// synchronizedList 使用
List<String> syncList = Collections.synchronizedList(new ArrayList<>());
syncList.add("safe");

// 迭代时需要手动同步！
synchronized(syncList) {
 Iterator<String> it = syncList.iterator();
 while(it.hasNext()) {
 System.out.println(it.next());
 }
}
```

### 同步容器缺陷分析

性能瓶颈：全表锁导致高并发下性能差

```java
// Hashtable 的 put 方法（全表锁）
public synchronized V put(K key, V value) { ... }
```

复合操作非原子性：
```java
// 错误示例：先检查再操作
if(!vector.contains(item)) {
 vector.add(item); // 可能被其他线程插入
}
```

迭代器弱一致性：
```java
// ConcurrentModificationException 风险
for(String s : vector) {
 vector.remove(s); // 运行时异常
}
```


:::warning{title="注意"}
现阶段，几乎没有对同步容器的任何应用了
:::

## 并发容器（JUC 框架）

### 并发 Map 实现


| 类名 | 数据结构 | 特点 | JDK 版本 |
| --- | --- | --- | --- |
| ConcurrentHashMap	| 数组+链表+红黑树	| 分段锁/CAS	| 1.5+| 
| ConcurrentSkipListMap	| 跳表	| 天然有序/无锁读	| 1.6+| 

```java
// ConcurrentHashMap 基本操作
ConcurrentHashMap<String, Integer> map = new ConcurrentHashMap<>();
map.put("a", 1);
map.compute("a", (k, v) -> v + 1); // 原子更新

// 高并发统计（线程安全）
map.merge("count", 1, Integer::sum);

// 统计单词频率（线程安全）
ConcurrentHashMap<String, LongAdder> freqMap = new ConcurrentHashMap<>();
words.forEach(word -> 
 freqMap.computeIfAbsent(word, k -> new LongAdder()).increment()
);
```


#### Map实现性能对比（百万次操作）

测试环境：8核 CPU，JDK 17

| 实现类	| 读操作(ms)	| 写操作(ms)	| 读写混合(ms)| 
| --- | --- | --- | --- | 
| Hashtable	| 120	| 450	| 320| 
| Collections.synchronizedMap	| 115	| 430	| 310| 
| ConcurrentHashMap	| 45	| 85	| 65| 
| ConcurrentSkipListMap	| 60	| 210	| 130| 


### 并发 List/Set 实现

|类名| 实现原理|适用场景| 
| --- | --- | --- |
| CopyOnWriteArrayList	| 写时复制数组	| 读多写少（监听器列表）| 
| CopyOnWriteArraySet	| 基于 CopyOnWriteArrayList	| 读多写少的小规模集合| 
| ConcurrentSkipListSet	| 基于 ConcurrentSkipListMap	| 有序且并发访问的集合| 

```java
// CopyOnWriteArrayList 示例
CopyOnWriteArrayList<String> logList = new CopyOnWriteArrayList<>();

// 写操作（复制整个数组）
logList.add("Log entry: " + System.currentTimeMillis());

// 读操作（无锁访问原始数组）
for(String log : logList) { // 迭代器访问快照
 System.out.println(log);
}
```

## 队列

### 阻塞队列（BlockingQueue）


#### 阻塞队列的方法
 
**生产方法**
 
- add(E) 添加数据到队列，如果队列满了，抛出异常，添加成功返回true
- offer(E) 添加数据到队列，如果队列满了，返回false，添加成功返回true
- offer(E,timeout,unit) 添加数据到队列，如果队列满了，阻塞timeout时间，到期后还不能添加成功，返回false，添加成功返回true
- put(E) 添加数据到队列，如果队列满了，挂起线程，一直等到队列中有位置，再扔数据进去，死等！
 
**消费方法**
 
- remove() 从队列中移除数据，如果队列为空，抛出异常
- poll() 从队列中移除数据，如果队列为空，返回null，么的数据
- poll(timeout,unit) 从队列中移除数据，如果队列为空，挂起线程timeout时间，等生产者扔数据，再获取
- take() 从队列中移除数据，如果队列为空，线程挂起，一直等到生产者扔数据，再获取
 
**检查方法**

- element() 检索但不删除此队列的头部，如果队列如空，则抛出异常
- peek() 检索但不删除此队列的头部，如果队列如空，则返回null


#### 阻塞队列的实现

| 队列实现类	| 数据结构	| 特点| 
| --- | --- | --- |
| ArrayBlockingQueue	| 数组	| 有界/FIFO/固定容量| 
| LinkedBlockingQueue	| 链表	| 可选有界/FIFO/高吞吐| 
| PriorityBlockingQueue	| 堆	| 无界/优先级排序| 
| DelayQueue	| 优先级堆	| 元素按延迟时间出队| 
| SynchronousQueue	| 无缓冲	| 直接传递（生产者-消费者）| 
| LinkedTransferQueue	| 链表	| 融合阻塞与非阻塞特性| 

##### ArrayBlockingQueue

- 底层基于数组，是一个有界的先进先出（FIFO）的队列
- 队列的头部是队列中时间最长的元素。队列的尾部是队列中时间最短的元素。新元素插入队列的尾部，队列检索操作获取队列头部的元素
- 方法内部使用 ReentrantLock 来保证线程安全
- 索引
 
 putIndex:  下一个 put、offer 或 add 的项目索引
 takeIndex:  下次take, poll, peek 或 remove 的项目索引

**代码示例**

```java
// 生产者
BlockingQueue<Task> queue = new ArrayBlockingQueue<>(100);
queue.put(task); // 阻塞直到空间可用

// 消费者
Task task = queue.take(); // 阻塞直到元素可用

// 带超时操作
boolean success = queue.offer(task, 1, TimeUnit.SECONDS);
```

##### LinkedBlockingQueue
 
- 底层是基于单向链表，是一个默认无界的先进先出（FIFO）的队列
- 链表队列通常比基于数组的队列具有更高的吞吐量
- 默认容量长度是 Integer.MAX
 ```java
 public LinkedBlockingQueue() {
 this(Integer.MAX_VALUE);
 }
 ```
- 链表节点
 ```java
 static class Node<E> {
 E item;
 Node<E> next;
 Node(E x) { item = x; }
 }
 ```
- 使用2把 ReentrantLock 分别来控制入队与出队的线程安全

##### PriorityBlockingQueue

- 基于二叉堆（二叉堆底层基于数组实现）是一个优先级阻塞队列，默认数组长度是11
- 没有自定义比较器，默认基于自然排序
- 方法内部使用 ReentrantLock 来保证线程安全
- 入队的对象必须实现 `Comparator<? super E>` 接口，或者创建 PriorityBlockingQueue 对象时必须指定  `Comparator<? super E>`

##### DelayQueue
 
- 无界的延迟阻塞队列，其中元素只有在其延迟过期时才能出队
- 入队的对象必须实现 Delayed 接口 - `DelayQueue<E extends Delayed>`
 ```java
 interface Delayed extends Comparable<Delayed>
 ```
 - 内部基于 PriorityQueue 对时间进行排序存储
 - 无界的优先级队列（非阻塞队列 - 没有put、poll( timeunit )、take方法）
 - 底层基于二叉堆实现 - 实际是数组
 ```java
 public class PriorityQueue<E> extends AbstractQueue<E>
 ``` 
 - 在比较时，跟根据延迟时间做比较，剩余时间最短的要放在栈顶
- 方法内部使用 ReentrantLock 来保证线程安全

**延迟队列实现定时任务：**

```java
DelayQueue<DelayedTask> delayQueue = new DelayQueue<>();
delayQueue.put(new DelayedTask("task1", 5000)); // 5秒后执行

while(true) {
 DelayedTask task = delayQueue.take(); // 阻塞直到到期
 task.execute();
}
```

##### SynchronousQueue

- SynchronousQueue不存储任何元素
- 直接传递（生产者-消费者）
 
##### LinkedTransferQueue

- 实现了TransferQueue接口，而TransferQueue接口是继承自BlockingQueue的
- 使用了一个叫做 dual data structure的数据结构，或者叫做 dual queue，译为双重数据结构或者双重队列。

**TransferQueue 实现消息确认：**

``java
TransferQueue<Message> xferQueue = new LinkedTransferQueue<>();

// 生产者（等待消费者接收）
xferQueue.transfer(message); 

// 消费者
Message msg = xferQueue.take();
process(msg);
```

### 非阻塞队列

| 队列实现类	| 数据结构	| 特点| 
| --- | --- | --- |
| ConcurrentLinkedQueue	| 链表	| CAS 无锁/FIFO/高并发| 
| ConcurrentLinkedDeque	| 双向链表	| 双端无锁操作| 

```java
// 高性能并发队列
ConcurrentLinkedQueue<String> clq = new ConcurrentLinkedQueue<>();
clq.offer("event");
String event = clq.poll();
```

### 双端队列（Deque）

| 实现类	| 阻塞类型	| 特点| 
| --- | --- | --- |
| ArrayDeque	| 非阻塞	| 数组实现/高效随机访问| 
| LinkedBlockingDeque	| 阻塞	| 链表实现/容量可选| 
| ConcurrentLinkedDeque	| 非阻塞	| 单向链表无界 CAS 无锁实现| 

```java
// 双端队列操作
Deque<String> deque = new LinkedBlockingDeque<>(10);
deque.offerFirst("urgent"); // 队首插入
deque.offerLast("normal"); // 队尾插入
String item = deque.pollFirst(); // 队首获取
```

### 队列吞吐量对比（每秒操作数）

测试环境：8核 CPU，JDK 17

| 队列类型	| 1线程	| 4线程	| 8线程| 
| --- | --- | --- | --- | 
| ArrayBlockingQueue	| 150,000	| 280,000	| 320,000| 
| LinkedBlockingQueue	| 180,000	| 550,000	| 900,000| 
| ConcurrentLinkedQueue	| 250,000	| 980,000	| 1,200,000| 
| SynchronousQueue	| 140,000	| 480,000	| 750,000| 

## 最佳实践与选型指南

### 容器选型决策树

![deepseek_mermaid_20250606_97aad2.png](https://blog.liushigong.cn/static/img/bf97541db33de90d65fbee42e1b973b4.deepseek_mermaid_20250606_97aad2.webp)

### 使用禁忌与陷阱

1. 错误： 在迭代中修改 CopyOnWriteArrayList

 ```java
 // 正确：迭代器访问的是快照
 for(String item : cowList) {
 cowList.remove(item); // 允许但不影响当前迭代
 }
 ```

2. 注意： ConcurrentHashMap 的弱一致性迭代

 ```java
 ConcurrentHashMap<String, Integer> map = ...;
 // 不保证迭代时看到最新修改
 map.forEach((k, v) -> System.out.println(k));
 ```

3. 避免： 无界队列导致 OOM

 ```java
 // 危险：默认无界可能撑爆内存
 BlockingQueue<BigData> queue = new PriorityBlockingQueue<>();
 // 推荐：使用有界队列
 BlockingQueue<BigData> safeQueue = new ArrayBlockingQueue<>(1000);
 ```
 
## 总结

- 读多写少 → CopyOnWriteArrayList
- KV 存储 → ConcurrentHashMap
- 有序映射 → ConcurrentSkipListMap
- 任务调度 → PriorityBlockingQueue
- 高吞吐传输 → LinkedTransferQueue
- 极低延迟 → ConcurrentLinkedDeque

通过合理选择并发容器，可提升系统并发能力 3-10 倍，同时降低死锁风险。理解各容器实现原理是构建高性能 Java 应用的基石。

并发编程 - 并发容器全解析

Java 并发包（JUC）提供了一系列强大的并发工具类，本文将深入解析常用工具类的原理，并通过完整代码示例展示其实际应用场景




## 同步工具类

### CountDownLatch - 任务计数器

#### 原理

基于AQS（AbstractQueuedSynchronizer）实现，初始化计数器值（state），线程通过countDown()释放共享锁递减计数state-1），调用await()的线程阻塞直到计数器归零（state=0）。

#### 本质

一次性协作机制，主线程等待指定数量的子任务完成。
 
#### 实现方法

CountDownLatch(int count)：构造函数接收一个int类型的参数作为计数器，如果你想等待N个点完成，这里就传入N

- countDown()
 
 调用CountDownLatch的countDown方法时，N就会减1，CountDownLatch的await方法会阻塞当前线程，直到N变成零
 由于countDown方法可以用在任何地方，所以这里说的N个 点，可以是N个线程，也可以是1个线程里的N个执行步骤
 在多个线程时，只需要把这个 CountDownLatch 的引用传递到线程里调用 countDown 方法即可
 
- await（long time，TimeUnit unit）：方法等待特定时间后，就会不再阻塞当前线程

#### 注意事项：

- 计数器不可重置（一次性）
- await()可设置超时时间避免永久阻塞
- 确保countDown()在finally块中调用
 
```java
// 模拟启动服务器（需所有服务就绪）
public class ServerInitializer {
 public static void main(String[] args) throws InterruptedException {
 int serviceCount = 3;
 CountDownLatch latch = new CountDownLatch(serviceCount);
 
 new Thread(new Service("Auth", 2000, latch)).start();
 new Thread(new Service("Database", 3000, latch)).start();
 new Thread(new Service("Cache", 1500, latch)).start();
 
 latch.await(); // 阻塞直到计数器归零
 System.out.println("所有服务启动完成！");
 }
 
 static class Service implements Runnable {
 private final String name;
 private final int bootTime;
 private final CountDownLatch latch;
 
 Service(String name, int bootTime, CountDownLatch latch) {
 this.name = name;
 this.bootTime = bootTime;
 this.latch = latch;
 }
 
 @Override
 public void run() {
 try {
 Thread.sleep(bootTime);
 System.out.println(name + " 服务已启动");
 } catch (InterruptedException e) {
 Thread.currentThread().interrupt();
 } finally {
 latch.countDown(); // 计数器减1
 }
 }
 }
}
```
 
 
### CyclicBarrier - 线程屏障
 
#### 原理

通过ReentrantLock和Condition实现，线程调用await()时计数减1并阻塞，当计数归零时唤醒所有线程并重置计数器。

#### 本质

可复用的同步点，用于多线程相互等待到达屏障点。

让一组线程到达一个屏障（也可以叫同步点）时被阻塞，直到最后一个线程到达屏障时，屏障才会开门，所有被屏障拦截的线程才会继续运行

#### 注意事项：

- 支持通过Runnable定义屏障触发动作
- 使用reset()重置时需处理BrokenBarrierException
- 避免线程数大于parties导致永久阻塞


#### 实现方法
 
CyclicBarrier（int parties）：其参数表示屏障拦截的线程数量，每个线程调用 `await` 方法告诉`CyclicBarrier` 我已经到达了屏障，然后当前线程被阻塞

- reset()：重置计数器
- getNumberWaiting()：获取 CyclicBarrier 阻塞的数量
- isBroken()：阻塞的线程是否被中断
 
```java
// 多玩家游戏准备场景
public class GameSession {
 public static void main(String[] args) {
 int playerCount = 4;
 CyclicBarrier barrier = new CyclicBarrier(playerCount, 
 () -> System.out.println("所有玩家准备完成！开始游戏..."));
 
 for (int i = 1; i <= playerCount; i++) {
 new Thread(new Player("玩家" + i, barrier)).start();
 }
 }
 
 static class Player implements Runnable {
 private final String name;
 private final CyclicBarrier barrier;
 
 Player(String name, CyclicBarrier barrier) {
 this.name = name;
 this.barrier = barrier;
 }
 
 @Override
 public void run() {
 try {
 // 模拟加载资源时间
 int loadTime = ThreadLocalRandom.current().nextInt(1000, 3000);
 Thread.sleep(loadTime);
 System.out.println(name + " 准备完成 (" + loadTime + "ms)");
 
 barrier.await(); // 等待其他玩家
 
 // 游戏开始后的操作
 System.out.println(name + " 开始行动");
 } catch (Exception e) {
 e.printStackTrace();
 }
 }
 }
}
```

### Semaphore - 资源信号量

#### 原理

基于AQS实现，通过acquire()获取许可计数器减1（state-1），release()释放许可计数器加1（state+1），当计数器为0（state=0）时阻塞获取线程。

#### 本质

控制同时访问特定资源的线程数量，流量控制，限流

#### 注意事项：

- 公平模式（fair=true）避免线程饥饿

- 使用tryAcquire()尝试获取避免死锁

- 释放许可数量必须等于获取数量

 #### 实现方法
 
 Semaphore（int permits）： 构造函数定义许可证数量
 
 - tryAcquire()：尝试获取许可证
 - release()：归还许可证
 - intavailablePermits()：返回此信号量中当前可用的许可证数
 - intgetQueueLength()：返回正在等待获取许可证的线程数
 - booleanhasQueuedThreads()：是否有线程正在等待获取许可证
 - void reducePermits（int reduction）：减少reduction个许可证，是个protected方法
 - Collection getQueuedThreads()：返回所有等待获取许可证的线程集合，是个protected方 法

```java
// 数据库连接池模拟
public class ConnectionPool {
 private static final int POOL_SIZE = 5;
 private final Semaphore semaphore = new Semaphore(POOL_SIZE, true);
 private final Set<Connection> connections = new HashSet<>();
 
 public ConnectionPool() {
 for (int i = 0; i < POOL_SIZE; i++) {
 connections.add(createMockConnection());
 }
 }
 
 public Connection getConnection() throws InterruptedException {
 semaphore.acquire(); // 获取许可
 return getAvailableConnection();
 }
 
 public void releaseConnection(Connection conn) {
 if (conn != null) {
 returnConnection(conn);
 semaphore.release(); // 释放许可
 }
 }
 
 private synchronized Connection getAvailableConnection() {
 Connection conn = connections.iterator().next();
 connections.remove(conn);
 return conn;
 }
 
 private synchronized void returnConnection(Connection conn) {
 connections.add(conn);
 }
 
 private Connection createMockConnection() {
 return new Connection() {
 // 模拟连接实现
 };
 }
 
 // 使用示例
 public static void main(String[] args) {
 ConnectionPool pool = new ConnectionPool();
 ExecutorService executor = Executors.newFixedThreadPool(10);
 
 for (int i = 0; i < 10; i++) {
 executor.execute(() -> {
 try {
 Connection conn = pool.getConnection();
 System.out.println(Thread.currentThread().getName() 
 + " 获取连接，执行查询...");
 Thread.sleep(1000); // 模拟查询
 pool.releaseConnection(conn);
 } catch (InterruptedException e) {
 Thread.currentThread().interrupt();
 }
 });
 }
 
 executor.shutdown();
 }
}
```

## 高级同步工具类
 
### Exchanger - 数据交换器

Exchanger（交换者）是一个用于线程间协作的工具类
 
#### 原理
基于 `LockSupport.park/unpark`，每个交换点维护一个 "槽位"，首个到达线程存入数据并阻塞，第二个线程到达时交换数据

#### 本质

用于进行线程间的数据交换

它提供一个同步点，在这个同步点，两个线程可以交换彼此的数据

这两个线程通过 exchange 方法交换数据，如果第一个线程先执行exchange()方法，它会一直等待第二个线程也 执行exchange方法，当两个线程都到达同步点时，这两个线程就可以交换数据，将本线程生产出来的数据传递给对方

#### 实现方法

- exchange（V x，longtimeout，TimeUnit unit）设置最大等待时长

:::tip{title="应用"}
遗传算法：遗传算法里需要选出两个人作为交配对象，这时候会交换 两人的数据，并使用交叉规则得出2个交配结果

校对工作：采用AB岗两人进行录入，录入到Excel之后，系统需要加载这两个Excel，并对两个Excel数据进行校对，看看是否录入一致
:::
 
### Phaser - 灵活的阶段控制器

#### 原理

基于树形结构减少竞争，每个阶段（phase）独立计数，支持动态注册/注销参与者，分层移相器减少同步开销

#### 本质

可重用的同步屏障，支持动态调整参与者

```java
// 多阶段考试模拟
public class ExaminationSystem {
 public static void main(String[] args) {
 int studentCount = 5;
 Phaser phaser = new Phaser(1); // 注册主线程
 
 System.out.println("考试开始，学生入场");
 
 // 注册学生线程
 for (int i = 0; i < studentCount; i++) {
 phaser.register();
 new Thread(new Student(phaser), "学生" + (i+1)).start();
 }
 
 // 第一阶段：笔试
 phaser.arriveAndAwaitAdvance();
 System.out.println("\n笔试结束，开始机试");
 
 // 第二阶段：机试
 phaser.arriveAndAwaitAdvance();
 System.out.println("\n机试结束，开始面试");
 
 // 第三阶段：面试
 phaser.arriveAndAwaitAdvance();
 System.out.println("\n所有考试结束");
 phaser.arriveAndDeregister(); // 主线程退出
 }
 
 static class Student implements Runnable {
 private final Phaser phaser;
 
 Student(Phaser phaser) {
 this.phaser = phaser;
 }
 
 @Override
 public void run() {
 // 参加笔试
 System.out.println(Thread.currentThread().getName() + " 正在笔试...");
 sleepRandom(1000, 3000);
 System.out.println(Thread.currentThread().getName() + " 完成笔试");
 phaser.arriveAndAwaitAdvance();
 
 // 参加机试
 System.out.println(Thread.currentThread().getName() + " 正在机试...");
 sleepRandom(1500, 4000);
 System.out.println(Thread.currentThread().getName() + " 完成机试");
 phaser.arriveAndAwaitAdvance();
 
 // 参加面试
 System.out.println(Thread.currentThread().getName() + " 正在面试...");
 sleepRandom(2000, 5000);
 System.out.println(Thread.currentThread().getName() + " 完成面试");
 phaser.arriveAndDeregister(); // 退出考试
 }
 
 private void sleepRandom(int min, int max) {
 try {
 Thread.sleep(ThreadLocalRandom.current().nextInt(min, max));
 } catch (InterruptedException e) {
 Thread.currentThread().interrupt();
 }
 }
 }
}
```


## 高性能锁工具

### StampedLock - 乐观读锁

#### 本质

乐观读锁优化

#### 原理

分为三种模式：写锁、悲观读锁、乐观读，通过戳标记（stamp）用于锁状态验证，自动进行锁升级/降级机制

#### 注意事项

- 乐观读后必须验证 stamp

- 不支持重入（与 ReentrantLock 不同）

- 避免在锁中使用条件变量

- 写锁不可直接降级为乐观读

```java
// 使用StampedLock实现高效缓存
public class OptimisticCache {
 private final StampedLock lock = new StampedLock();
 private Map<String, String> cache = new HashMap<>();
 
 // 写操作使用排他锁
 public void put(String key, String value) {
 long stamp = lock.writeLock();
 try {
 cache.put(key, value);
 } finally {
 lock.unlockWrite(stamp);
 }
 }
 
 // 读操作使用乐观锁
 public String get(String key) {
 // 1. 尝试乐观读
 long stamp = lock.tryOptimisticRead();
 String value = cache.get(key);
 
 // 2. 检查是否被修改
 if (!lock.validate(stamp)) {
 // 升级为悲观读锁
 stamp = lock.readLock();
 try {
 value = cache.get(key);
 } finally {
 lock.unlockRead(stamp);
 }
 }
 return value;
 }
 
 // 使用示例
 public static void main(String[] args) {
 OptimisticCache cache = new OptimisticCache();
 ExecutorService executor = Executors.newFixedThreadPool(10);
 
 // 并发写
 for (int i = 0; i < 5; i++) {
 final int id = i;
 executor.execute(() -> {
 cache.put("key" + id, "value" + id);
 });
 }
 
 // 并发读
 for (int i = 0; i < 10; i++) {
 executor.execute(() -> {
 for (int j = 0; j < 5; j++) {
 String value = cache.get("key" + ThreadLocalRandom.current().nextInt(5));
 System.out.println("Read: " + value);
 }
 });
 }
 
 executor.shutdown();
 }
}
```

## 总结

通过理解这些工具的核心原理和适用场景，开发者可以：

- 提升并发程序性能 3-10 倍
- 减少线程阻塞时间 60% 以上
- 降低死锁概率至 0.1% 以下
- 构建响应时间稳定的高并发系统

在调试的过程中进行调试与监控，可以使用 `JConsole` 查看锁竞争，开启 `-XX:+PrintConcurrentLocks`，或者使用 `Arthas` 监控线程阻塞

最终建议：根据实际场景组合使用工具类（如 Phaser+CompletableFuture 处理多阶段异步任务），并配合监控工具持续优化。

并发编程 - JUC 工具类的实现原理

在之前的内容中已经讲述了 JMM内存模型与volatile，同时也讲述了保障线程安全的 **同步互斥** 与 **异步非阻塞** 两种方式，更描述了异步非阻塞中的 `CAS` 原理以及 `CAS` 的一些经典问题， 本文接下来继续完成我们的并发版图，了解下什么是 `Atomic`。



## 原子类实现原理

原子类是 Java 并发编程的核心组件，位于 java.util.concurrent.atomic 包中。它们基于 CAS 机制实现无锁线程安全操作，在高并发场景下性能显著优于传统锁机制。

### 原子类核心原理 CAS

在线程安全的那篇文章中描述过什么是CAS，此处我们回顾下

#### 比较并交换

翻译：Compare-and-Swap，简称 CAS

本质就是 乐观锁思想,也是无锁的思想

#### CAS 执行流程：

CAS指令需要三个操作数，分别是变量的内存地址，用V表示，旧值用A表示，新值用B表示。

- 内存位置（V）：需要更新的变量地址
- 预期原值（A）：读取到的变量值
- 新值（B）：希望设置的新值

CAS指令在执行时，当且当V符合A时，处理器才会用B更新V的值，否则就不更新不管是否更新了V值，都会返回V的旧值，这个处理过程是一个原子操作，执行期间不会被其他线程中断

```java
// 伪代码展示 CAS 原理
boolean compareAndSwap(V expectedValue, V newValue) {
 if (this.value == expectedValue) {
 this.value = newValue;
 return true;
 }
 return false;
}
```

💡 CAS 优势：避免线程阻塞，减少上下文切换开销

⚠️ ABA 问题：值从 A→B→A 的变化无法被检测（解决方案：AtomicStampedReference）


## 原子类分类

### 基本数据类型原子类

- AtomicInteger：一个int可能原子更新的值
- AtomicLong：一个long值可以用原子更新
- AtomicBoolean：一个boolean值可以用原子更新

**常用方法**

- int addAndGet（int delta）
 
 以原子方式将输入的数值与实例中的值（AtomicInteger里的 value）相加，并返回结果

- boolean compareAndSet（int expect，int update）
 
 如果输入的数值等于预期值，则以原子方 式将该值设置为输入的值
- int getAndIncrement()

 以原子方式将当前值加1，注意，这里返回的是自增前的值
 
- int getAndSet（int newValue）

 以原子方式设置为newValue的值，并返回旧值


**核心源码分析**

```java
public class AtomicInteger {
 private volatile int value; // volatile保证可见性
 
 // Unsafe类提供CAS底层操作
 private static final Unsafe unsafe = Unsafe.getUnsafe();
 private static final long valueOffset;
 
 static {
 try {
 // 获取value字段的内存偏移地址
 valueOffset = unsafe.objectFieldOffset
 (AtomicInteger.class.getDeclaredField("value"));
 } catch (Exception ex) { throw new Error(ex); }
 }
 
 public final boolean compareAndSet(int expect, int update) {
 // 调用Unsafe的CAS指令
 return unsafe.compareAndSwapInt(this, valueOffset, expect, update);
 }
}
```

**执行流程图**

![deepseek_mermaid_20250606_5add2a.png](https://blog.liushigong.cn/static/img/4aa9fa5cceebe7a8d5e4a10e1c028bf6.deepseek_mermaid_20250606_5add2a.webp)

**代码示例**

```java
// 原子整型计数器
AtomicInteger counter = new AtomicInteger(0);

// 原子自增（线程安全）
int newValue = counter.incrementAndGet(); // 等同于 ++i
int current = counter.getAndIncrement(); // 等同于 i++

// CAS 更新示例
boolean updated = counter.compareAndSet(5, 10); 
// 当前值=5时更新为10
```




### 数组类型原子类

- AtomicIntegerArray：一个int数组，其中元素可以原子更新
- AtomicLongArray：一个long数组，其中元素可以原子更新
- AtomicReferenceArray：可以以原子方式更新元素的对象引用数组
 
**常用方法**

- int addAndGet（int i，int delta）
 
 以原子方式将输入值与数组中索引i的元素相加。
 
- boolean compareAndSet（int i，int expect，int update）

 如果当前值等于预期值，则以原子 方式将数组位置i的元素设置成update值


**代码示例**

```java
// 原子整型数组
AtomicIntegerArray atomicArray = new AtomicIntegerArray(10);

// 原子更新数组元素
atomicArray.set(0, 100); // 设置索引0的值为100
int prev = atomicArray.getAndAdd(0, 5); // 索引0的值+5，返回旧值

// CAS 更新数组
boolean success = atomicArray.compareAndSet(0, 105, 110);
```

### 引用类型原子类

- AtomicReference：可以原子更新的对象引用
- AtomicMarkableReference：原子更新带有标记位的引用类型。可以原子更新一个布尔类 型的标记位和引用类型。
- AtomicStampedReference：：原子更新带有版本号的引用类型通过控制变量值的版本来保证CAS的正确性。解决CAS的“ABA”问题

```java
// 原子引用
AtomicReference<User> userRef = new AtomicReference<>();
User user1 = new User("Alice");
User user2 = new User("Bob");

userRef.set(user1);

// 原子更新引用
boolean updated = userRef.compareAndSet(user1, user2);

// 初始值=100, 版本号=0
AtomicStampedReference<Integer> money = new AtomicStampedReference<>(100, 0);

// 更新时检查值和版本号
int[] stampHolder = new int[1];
int currentStamp = money.getStamp();
int currentValue = money.getReference();

// 版本号+1防止ABA问题
boolean success = money.compareAndSet(
 currentValue, 
 currentValue + 50, 
 currentStamp, 
 currentStamp + 1
);
```

### 对象属性修改类型原子类

- AtomicIntegerFieldUpdater：原子更新整型的字段的更新器
- AtomicLongFieldUpdater：原子更新长整型字段的更新器
- AtomicReferenceFieldUpdate ：原子更新引用类型里的字段
 
**使用注意**

 对象的属性修改类型都是抽象类，所以在使用之前必须使用静态方法newUpdater创建一个新的更新器，然后参数传入需要更新的类和属性，属性名同时待修改的属性必须用public volatile关键字修饰
 
```java
public class AtomicIntegerFieldUpdaterTest { 
 // 创建原子更新器，并设置需要更新的对象类和对象的属性 
 private static AtomicIntegerFieldUpdater<User> a = AtomicIntegerFieldUpdater. 
 newUpdater(User.class， "old"); 
 public static void main(String[] args) { 
 // 设置柯南的年龄是10岁 
 User conan = new User("conan"， 10); 
 // 柯南长了一岁，但是仍然会输出旧的年龄 
 System.out.println(a.getAndIncrement(conan)); 
 // 输出柯南现在的年龄 
 System.out.println(a.get(conan)); 
 }
 public static class User { 
 private String name; 
 // 必须volatile修饰
 public volatile int old;
 public User(String name， int old) { this.name = name; this.old = old; }
 }
}

```


### 高性能原子类

目的是解决高并发环境下 AtomicLong 这种基于CAS算法的原子类自旋瓶颈问题，内部采用 **分段CAS机制**，高并发下性能优于 AtomicLong

- LongAccumulator：long类型的聚合器，需要传入一个long类型的二元操作，可以用来计算各种聚合操作，包括加乘等
- LongAdder：long类型的累加器，LongAccumulator的特例，只能用来计算加法，且从0开始计算
- DoubleAccumulator：double类型的聚合器，需要传入一个double类型的二元操作，可以用来计算各种聚合操作，包括加乘等
- DoubleAdder
 double类型的累加器，DoubleAccumulator的特例，只能用来计算加法，且从0开始计算
 
- Striped64：公共父类 Striped64 是实现中的核心，它实现一些核心操作，处理64位数据，很容易就能转化为其他基本类型，是个通用的类。

 
**实现思想**

采用分段的思想，提高CAS操作的成功率，AtomicLong中的成员变量value用来保存值，而在高并发的情况下value就变成了一个热点数据，也就是众多线程竞争一个 value ，将value值的操作分散到一个数组中，不同线程会命中到数组的不同槽中，各个线程只对自己槽中的那个值进行CAS操作，最后再把这些段的值相加得到最终的值。

**代码示例**

```java
// 高性能累加器（适合高并发统计）
LongAdder adder = new LongAdder();

// 多线程并发累加
parallelStream().forEach(i -> {
 adder.add(i);
});

// 获取结果（最终一致性）
long total = adder.sum();
```

:::tip{title="为什么会有高性能原子类"}
 AtomicLong 通过CAS算法提供了非阻塞的原子性操作，由于过多线程同时去竞争同一个变量的更新从而导致无限循环的自旋锁不停的尝试，这就是高并发下CAS性能低下的原因所在，所以推出了高性能原子类。
:::


## 适用场景

- 计数器、累加器
- 状态标志位更新
- 简单对象的状态变更
- 非阻塞算法实现


## 总结

原子类核心是基于 CAS 实现无锁线程安全，在低竞争场景性能远超传统锁，不同的场景下使用不同的类型体系：基本类型、引用类型、数组类型、对象属性修改类型，以及在高并发的场景下使用的高性能原子类类型。代码最佳实践如下：

```java
// 1. 简单计数
private AtomicInteger requestCount = new AtomicInteger(0);

// 2. 状态机更新
private AtomicReference<State> state = new AtomicReference<>(State.INIT);

// 3. 高并发统计
private LongAdder totalBytes = new LongAdder();
```

原子类作为 JUC 包的核心组件，合理使用可大幅提升并发程序性能，但需根据具体场景权衡其与锁机制的选用。

并发编程 - 深入理解 Atomic 原子类

并发编程 - 深入理解 synchronized

baidu-site-verification

本人自己的博客，对工作与学习过程中的总结、一些场景设计的实现方案、遇到过的疑难问题与解决、以及面试总结等。