在多线程编程中，HashMap是非线程安全的，而Hashtable虽然是线程安全的，但性能较差。ConcurrentHashMap应运而生，它提供了更好的并发性能和线程安全性。本文将详细介绍ConcurrentHashMap的使用方法。

## ConcurrentHashMap概述

ConcurrentHashMap是Java并发包(java.util.concurrent)中的一个线程安全的HashMap实现。与Hashtable不同，它使用分段锁（Java 7）或CAS操作（Java 8+）来实现更高的并发性能。

### 主要特性

- **线程安全**：多个线程可以同时读写而不会导致数据不一致
- **高并发性能**：读操作通常不需要加锁，写操作使用细粒度锁
- **弱一致性**：迭代器不会抛出ConcurrentModificationException
- **不支持null键和null值**

## 基本使用方法

### 1. 创建ConcurrentHashMap

```java
import java.util.concurrent.ConcurrentHashMap;

// 创建空的ConcurrentHashMap
ConcurrentHashMap<String, Integer> map1 = new ConcurrentHashMap<>();

// 创建指定初始容量的ConcurrentHashMap
ConcurrentHashMap<String, Integer> map2 = new ConcurrentHashMap<>(32);

// 从现有Map创建
Map<String, Integer> existingMap = new HashMap<>();
existingMap.put("A", 1);
existingMap.put("B", 2);
ConcurrentHashMap<String, Integer> map3 = new ConcurrentHashMap<>(existingMap);

// 创建指定初始容量和负载因子的ConcurrentHashMap
ConcurrentHashMap<String, Integer> map4 = new ConcurrentHashMap<>(16, 0.75f);

// 创建指定初始容量、负载因子和并发级别的ConcurrentHashMap
ConcurrentHashMap<String, Integer> map5 = new ConcurrentHashMap<>(16, 0.75f, 8);
```

### 2. 基本操作

```java
ConcurrentHashMap<String, Integer> concurrentMap = new ConcurrentHashMap<>();

// 添加元素
concurrentMap.put("apple", 10);
concurrentMap.put("banana", 20);
concurrentMap.put("orange", 15);

// 如果键不存在则添加
concurrentMap.putIfAbsent("apple", 50);  // 不会执行，因为"apple"已存在
concurrentMap.putIfAbsent("grape", 30);  // 会添加，因为"grape"不存在

// 获取元素
Integer apples = concurrentMap.get("apple");  // 返回10
Integer unknown = concurrentMap.get("unknown");  // 返回null

// 检查键是否存在
boolean hasApple = concurrentMap.containsKey("apple");  // true
boolean hasMango = concurrentMap.containsKey("mango");  // false

// 删除元素
concurrentMap.remove("banana");  // 删除键为"banana"的条目
concurrentMap.remove("orange", 10);  // 只有当键为"orange"且值为10时才删除

// 获取大小
int size = concurrentMap.size();

// 检查是否为空
boolean isEmpty = concurrentMap.isEmpty();
```

## 高级操作方法

### 1. 原子更新操作

```java
ConcurrentHashMap<String, Integer> inventory = new ConcurrentHashMap<>();
inventory.put("widget", 100);

// compute方法：根据现有键值对计算新值
inventory.compute("widget", (key, value) -> value == null ? 1 : value + 50);
// 现在widget的值为150

// computeIfAbsent：如果键不存在，计算新值
inventory.computeIfAbsent("gadget", key -> 200);
// gadget不存在，所以设置为200

// computeIfPresent：如果键存在，计算新值
inventory.computeIfPresent("widget", (key, value) -> value - 10);
// widget存在，所以值变为140

// merge方法：合并值
inventory.merge("widget", 50, (oldValue, newValue) -> oldValue + newValue);
// widget的值变为190 (140 + 50)
```

### 2. 批量操作

```java
ConcurrentHashMap<String, String> userSessions = new ConcurrentHashMap<>();
userSessions.put("user1", "session1");
userSessions.put("user2", "session2");
userSessions.put("user3", "session3");

// forEach：遍历所有条目
userSessions.forEach((key, value) -> 
    System.out.println("User: " + key + ", Session: " + value));

// forEach带并行阈值
userSessions.forEach(2, (key, value) -> 
    System.out.println("Processing: " + key));

// reduce：归约操作
ConcurrentHashMap<String, Integer> scores = new ConcurrentHashMap<>();
scores.put("Alice", 85);
scores.put("Bob", 92);
scores.put("Charlie", 78);

int totalScore = scores.reduce(2, (key, value) -> value, Integer::sum);
System.out.println("Total score: " + totalScore);

// search：搜索操作
String found = scores.search(2, (key, value) -> value > 90 ? key : null);
System.out.println("Score > 90: " + found);  // 输出: Bob
```

## 线程安全实践

### 1. 多线程读写示例

```java
public class ConcurrentHashMapExample {
    private final ConcurrentHashMap<String, AtomicInteger> counterMap = 
        new ConcurrentHashMap<>();
    
    // 线程安全的计数方法
    public void increment(String key) {
        counterMap.compute(key, (k, v) -> {
            if (v == null) {
                return new AtomicInteger(1);
            } else {
                v.incrementAndGet();
                return v;
            }
        });
    }
    
    // 或者使用更简洁的方式
    public void incrementBetter(String key) {
        counterMap.computeIfAbsent(key, k -> new AtomicInteger(0)).incrementAndGet();
    }
    
    public int getCount(String key) {
        AtomicInteger counter = counterMap.get(key);
        return counter == null ? 0 : counter.get();
    }
}
```

### 2. 缓存实现示例

```java
public class SimpleCache<K, V> {
    private final ConcurrentHashMap<K, V> cache = new ConcurrentHashMap<>();
    private final long defaultExpiry;
    
    public SimpleCache(long defaultExpiryMillis) {
        this.defaultExpiry = defaultExpiryMillis;
    }
    
    public V get(K key) {
        return cache.get(key);
    }
    
    public void put(K key, V value) {
        cache.put(key, value);
    }
    
    public V getOrCompute(K key, Supplier<V> supplier) {
        return cache.computeIfAbsent(key, k -> supplier.get());
    }
    
    public boolean remove(K key) {
        return cache.remove(key) != null;
    }
    
    public void clear() {
        cache.clear();
    }
}
```

## 与其它Map的对比

### 性能比较

```java
public class MapComparison {
    public static void main(String[] args) throws InterruptedException {
        // 测试HashMap（非线程安全）
        Map<String, Integer> hashMap = new HashMap<>();
        testMapPerformance(hashMap, "HashMap");
        
        // 测试Hashtable（线程安全，但性能较差）
        Map<String, Integer> hashtable = new Hashtable<>();
        testMapPerformance(hashtable, "Hashtable");
        
        // 测试ConcurrentHashMap（线程安全，高性能）
        Map<String, Integer> concurrentHashMap = new ConcurrentHashMap<>();
        testMapPerformance(concurrentHashMap, "ConcurrentHashMap");
    }
    
    private static void testMapPerformance(Map<String, Integer> map, String mapType) 
            throws InterruptedException {
        int threadCount = 10;
        int operationsPerThread = 10000;
        
        Thread[] threads = new Thread[threadCount];
        long startTime = System.currentTimeMillis();
        
        for (int i = 0; i < threadCount; i++) {
            final int threadId = i;
            threads[i] = new Thread(() -> {
                for (int j = 0; j < operationsPerThread; j++) {
                    String key = "key-" + threadId + "-" + j;
                    map.put(key, j);
                    map.get(key);
                }
            });
            threads[i].start();
        }
        
        for (Thread thread : threads) {
            thread.join();
        }
        
        long endTime = System.currentTimeMillis();
        System.out.println(mapType + " 耗时: " + (endTime - startTime) + "ms");
    }
}
```

## 最佳实践

### 1. 选择合适的初始容量

```java
// 如果知道大概的元素数量，设置合适的初始容量可以提高性能
int expectedSize = 100000;
ConcurrentHashMap<String, Object> map = new ConcurrentHashMap<>(
    (int)(expectedSize / 0.75f) + 1
);
```

### 2. 使用合适的并发级别

```java
// 根据预期的并发线程数设置并发级别
int expectedThreads = 16;
ConcurrentHashMap<String, Object> map = new ConcurrentHashMap<>(
    16, 0.75f, expectedThreads
);
```

### 3. 避免在遍历时修改结构

```java
ConcurrentHashMap<String, Integer> map = new ConcurrentHashMap<>();
map.put("A", 1);
map.put("B", 2);
map.put("C", 3);

// 安全的遍历方式
for (String key : map.keySet()) {
    System.out.println(key + ": " + map.get(key));
    // 在遍历过程中可以安全地修改值，但不能添加/删除键
    map.put(key, map.get(key) + 1);  // 安全
    // map.remove(key);  // 可能导致未定义行为
}
```

### 4. 使用原子操作复合操作

```java
// 不安全的做法
if (!map.containsKey(key)) {
    map.put(key, value);  // 这不是原子操作！
}

// 安全的做法
map.putIfAbsent(key, value);

// 或者使用computeIfAbsent
map.computeIfAbsent(key, k -> createExpensiveValue(k));
```

## 常见问题与解决方案

### 1. 内存一致性问题

```java
// 错误用法：check-then-act模式
if (concurrentMap.containsKey(key)) {
    // 在这期间，其他线程可能已经删除了该键
    Value value = concurrentMap.get(key);  // 可能返回null
    process(value);  // 可能抛出NullPointerException
}

// 正确用法：原子操作
Value value = concurrentMap.get(key);
if (value != null) {
    process(value);
}
```

### 2. 迭代器弱一致性

```java
ConcurrentHashMap<String, Integer> map = new ConcurrentHashMap<>();
map.put("A", 1);
map.put("B", 2);

Iterator<Map.Entry<String, Integer>> iterator = map.entrySet().iterator();
while (iterator.hasNext()) {
    Map.Entry<String, Integer> entry = iterator.next();
    System.out.println(entry.getKey() + ": " + entry.getValue());
    // 其他线程在此期间修改map不会影响当前迭代
    // 但也不会在迭代器中反映这些变化
}
```

## 总结

ConcurrentHashMap是Java并发编程中的重要工具，它提供了：

- **高性能的线程安全Map实现**
- **丰富的原子操作方法**
- **良好的扩展性**
- **弱一致性的迭代器**

在使用时需要注意：
- 选择合适的初始容量和并发级别
- 使用原子操作代替check-then-act模式
- 理解迭代器的弱一致性特性
- 避免在遍历时进行结构修改

通过合理使用ConcurrentHashMap，可以构建出高性能、线程安全的并发应用程序。

Java中ConcurrentHashMap如何使用？

> **作者注**：本文将带你快速了解并上手 Spring Boot 下的一站式优雅响应解决方案 —— **Graceful Response**，让你的接口开发更简洁、更规范、更高效。

---

## 一、简介

**Graceful Response** 是一个基于 **Spring Boot** 技术栈的优雅响应处理器，提供以下功能：

*  统一返回值封装
*  全局异常处理
*  自定义异常与错误码映射
*  参数校验增强

使用 **Graceful Response** 进行 Web 接口开发，不仅能节省大量模板式代码，还能显著提升代码质量与可读性，让逻辑更加清晰。

 示例工程地址：
 [https://github.com/feiniaojin/graceful-response-example.git](https://github.com/feiniaojin/graceful-response-example.git)

### 版本对应关系

| Spring Boot 版本 | Graceful Response 版本      | 示例分支     |
| -------------- | ------------------------- | -------- |
| 2.x            | 3.2.1-boot2 / 3.2.0-boot2 | boot2 分支 |
| 3.x            | 3.2.1-boot3 / 3.2.0-boot3 | boot3 分支 |

> 注意：3.2.1-boot2 版本源码由独立仓库维护 → [graceful-response-boot2](https://github.com/feiniaojin/graceful-response-boot2)
> 除了 Spring Boot 版本不同，其他实现完全一致。

---

## 二、为什么需要 Graceful Response？

### 1. 传统 Controller 的痛点

一个常见的 Controller 示例：

```java
@Controller
public class Controller {

    @GetMapping("/query")
    @ResponseBody
    public Response query(Map<String, Object> paramMap) {
        Response res = new Response();
        try {
            if (illegal(paramMap)) {
                res.setCode(1);
                res.setMsg("error");
                return res;
            }
            Object data = service.query(paramMap);
            res.setData(data);
            res.setCode(0);
            res.setMsg("ok");
            return res;
        } catch (Exception e) {
            res.setCode(1);
            res.setMsg("error");
            return res;
        }
    }
}
```

返回格式如下：

```json
{
  "code": 0,
  "msg": "ok",
  "data": {
    "id": 1,
    "name": "username"
  }
}
```

#### 存在的问题：

1. **效率低下**
   代码中大量重复的异常捕获与结果封装逻辑。

2. **重复劳动**
   每个接口都要写同样的 try...catch 和封装逻辑。

3. **可读性差**
   核心业务逻辑被冗余代码淹没，维护困难。

---

## 三、快速上手 Graceful Response

### 3.1 引入依赖

在 `pom.xml` 中加入：

```xml
<dependency>
    <groupId>com.feiniaojin</groupId>
    <artifactId>graceful-response</artifactId>
    <version>{latest.version}</version>
</dependency>
```

### 3.2 启用 Graceful Response

在 Spring Boot 启动类上添加注解：

```java
@EnableGracefulResponse
@SpringBootApplication
public class ExampleApplication {
    public static void main(String[] args) {
        SpringApplication.run(ExampleApplication.class, args);
    }
}
```

---

## 四、Controller 层使用示例

引入 Graceful Response 后，Controller 无需手动封装返回结果：

```java
@Controller
public class Controller {

    @RequestMapping("/get")
    @ResponseBody
    public UserInfoView get(Long id) {
        log.info("id={}", id);
        return UserInfoView.builder().id(id).name("name" + id).build();
    }
}
```

返回结果自动封装为：

```json
{
  "status": {
    "code": "0",
    "msg": "ok"
  },
  "payload": {
    "id": 1,
    "name": "name1"
  }
}
```

对于无返回值（Command）操作：

```java
@RequestMapping("/command")
@ResponseBody
public void command() {
    // 业务操作
}
```

返回结果自动为：

```json
{
  "status": {
    "code": "200",
    "msg": "success"
  },
  "payload": {}
}
```

---

## 五、Service 层与异常处理

### 5.1 传统写法的问题

有些开发者直接让 Service 层返回 `Response` 对象：

```java
@Data
public class Response {
    private String code;
    private String msg;
    private Object data;
}
```

这种做法污染了业务逻辑，不规范。

---

### 5.2 使用 @ExceptionMapper 优化

Graceful Response 通过 `@ExceptionMapper` 将异常与错误码绑定。

```java
@ExceptionMapper(code = "1404", msg = "找不到对象")
public class NotFoundException extends RuntimeException {}
```

Service 示例：

```java
public interface QueryService {
    UserInfoView queryOne(Query query);
}

public class QueryServiceImpl implements QueryService {

    @Resource
    private UserInfoMapper mapper;

    @Override
    public UserInfoView queryOne(Query query) {
        UserInfo userInfo = mapper.findOne(query.getId());
        if (Objects.isNull(userInfo)) {
            throw new NotFoundException();
        }
        return new UserInfoView(...);
    }
}
```

当抛出 `NotFoundException` 时，接口返回：

```json
{
  "status": {
    "code": "1404",
    "msg": "找不到对象"
  },
  "payload": {}
}
```

---

## 六、参数校验增强

Graceful Response 与 **JSR-303 / Hibernate Validator** 无缝集成，并支持通过 `@ValidationStatusCode` 指定错误码。

### 示例一：实体校验

```java
@Data
public class UserInfoQuery {

    @NotNull(message = "userName is null !")
    @Length(min = 6, max = 12)
    @ValidationStatusCode(code = "520")
    private String userName;
}
```

当校验不通过时，返回：

```json
{
  "status": {
    "code": "520",
    "msg": "userName is null !"
  },
  "payload": {}
}
```

### 示例二：方法参数校验

```java
@RequestMapping("/validateMethodParam")
@ResponseBody
@ValidationStatusCode(code = "1314")
public void validateMethodParam(
        @NotNull(message = "userId不能为空") Long userId,
        @NotNull(message = "userName不能为空") Long userName) {
    // 业务逻辑
}
```

返回结果：

```json
{
  "status": {
    "code": "1314",
    "msg": "userId不能为空"
  },
  "payload": {}
}
```

---

## 七、自定义 Response 格式

Graceful Response 内置两种风格，通过配置项设置：

### 7.1 默认格式（style=0）

```properties
graceful-response.response-style=0
```

```json
{
  "status": {
    "code": 1007,
    "msg": "有内鬼，终止交易"
  },
  "payload": {}
}
```

### 7.2 简洁格式（style=1）

```properties
graceful-response.response-style=1
```

```json
{
  "code": "1404",
  "msg": "not found",
  "data": {}
}
```

### 7.3 自定义响应格式

如果默认两种格式不满足需求，Graceful Response 也支持 **完全自定义响应结构**。
具体实现请参考官方文档中的 *自定义Response格式* 章节。

---

## 八、更多进阶功能

*  **第三方组件支持**（Swagger、Actuator 等）
*  **异常请求放行与别名机制**
* ⚙ **常用配置项**
*  **多模块项目兼容**

 该组件在 GitHub 上已获得 **200+ Star**，并被众多开发者在生产环境中使用。
 项目主页：[https://github.com/feiniaojin/graceful-response](https://github.com/feiniaojin/graceful-response)

---

##  总结

Graceful Response 是一个轻量但强大的 Spring Boot 插件，
它让我们从繁琐的异常处理与统一返回封装中解放出来。

**一句话总结：**

> *让你的 Controller 只负责业务逻辑，让 Graceful Response 负责优雅响应。*



优雅响应处理器 Graceful Response 全面解析与实战指南

在MyBatis项目中，手动写`LIMIT`语句进行分页不仅繁琐，而且难以维护。PageHelper通过一句代码就能实现物理分页，极大提升开发效率。

#### **一、快速入门**

**1. 引入依赖**
```xml

<dependency>
    <groupId>com.github.pagehelper</groupId>
    <artifactId>pagehelper-spring-boot-starter</artifactId>
    <version>最新版本</version>
</dependency>
```

**2. 基础使用（核心用法）**
在查询方法前调用`PageHelper.startPage`即可。

```java
@Service
public class UserService {
    
    @Autowired
    private UserMapper userMapper;
    
    public PageInfo<User> getUsers(int pageNum, int pageSize) {
        // 只有紧跟在后的第一个MyBatis查询方法会被分页
        PageHelper.startPage(pageNum, pageSize);
        List<User> userList = userMapper.selectAll();
        return new PageInfo<>(userList);
    }
}
```

**3. 返回结果**
`PageInfo`对象包含完整的分页信息：
```json
{
  "pageNum": 1,
  "pageSize": 10,
  "total": 100,
  "list": [...], // 当前页数据
  "hasNextPage": true,
  "pages": 10 // 总页数
}
```

#### **二、实用技巧**

**1. 更简洁的写法（推荐）**
使用`PageMethod`的静态方法，代码更清晰：
```java
PageInfo<User> pageInfo = PageMethod.startPage(pageNum, pageSize)
    .doSelectPageInfo(() -> userMapper.selectByCondition(condition));
```

**2. 排序支持**
```java
// 单字段排序
PageHelper.startPage(pageNum, pageSize, "create_time DESC");

// 多字段排序
String orderBy = "name ASC, id DESC";
PageHelper.startPage(pageNum, pageSize, orderBy);
```

**3. 只获取总数不查数据**
```java
Page<?> page = PageHelper.startPage(pageNum, pageSize, true);
userMapper.selectComplexQuery(params);
long total = page.getTotal(); // 获取总数，list为空
```

**4. 参数安全处理**
```java
// 设置分页参数合理范围
public PageInfo<User> safeQuery(int pageNum, int pageSize) {
    pageNum = Math.max(1, pageNum); // 至少第一页
    pageSize = Math.min(100, Math.max(1, pageSize)); // 限制1-100条
    return PageMethod.startPage(pageNum, pageSize)
           .doSelectPageInfo(() -> userMapper.selectAll());
}
```

#### **三、避坑指南**

**1. 线程安全问题**
- PageHelper基于ThreadLocal，确保在** finally 块**中清理，或使用`PageMethod`的lambda写法自动清理

**2. 分页失效的常见原因**
- 没有紧跟在查询方法前调用
- 在代码执行路径中出现了多次`startPage`
- 配置了`defaultCount=false`且没有手动指定`count`查询

**3. 一对多查询的分页问题**
在`resultMap`中使用`collection`会导致分页总数不准，解决方案：
- 使用子查询代替`collection`
- 先分页查询主表，再批量查询关联数据

**4. 自定义Count查询**
对于复杂查询，可以指定专用的count语句：
```java
@Select({"<script>",
         "SELECT * FROM user WHERE 1=1",
         "<when test='name!=null'> AND name like #{name}</when>",
         "</script>"})
List<User> selectComplex(UserQuery query);

// 对应的count查询
@Select({"<script>",
         "SELECT COUNT(1) FROM user WHERE 1=1", 
         "<when test='name!=null'> AND name like #{name}</when>",
         "</script>"})
Long countComplex(UserQuery query);
```

#### **四、最佳实践**

1. **统一分页响应**：封装统一的`PageResult`类，避免直接返回`PageInfo`
2. **配置合理化**：在yml中设置`reasonable=true`，页码超出范围时自动修正
3. **性能优化**：复杂count查询考虑缓存或估算总数

**配置示例：**
```yaml
pagehelper:
  helper-dialect: mysql
  reasonable: true
  support-methods-arguments: true
```

**总结**：PageHelper用最简单的API解决了最繁琐的分页问题，掌握这些技巧能让你的分页代码更加健壮和高效。