Spring Boot中并发问题的简单处理

最新推荐文章于 2025-05-09 15:14:45 发布

洗发水很好用

最新推荐文章于 2025-05-09 15:14:45 发布

阅读量1.4k

点赞数 21

文章标签： java 数据库开发语言

本文链接：https://blog.youkuaiyun.com/a983677218/article/details/145174845

版权

解决多个用户同时访问一个接口可能产生并发问题，下面用一个生成编号的接口做示例。并发情况下可能生成相同编号。

一、使用同步机制

（一）使用 `synchronized` 关键字

如果是单实例部署，可以使用 synchronized 关键字来保证代码块的同步执行。例如：

import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class SampleController {

    private int counter = 0;

    @GetMapping("/generateId")
    public synchronized String generateId() {
        // 生成编号的逻辑
        counter++;
        return "ID-" + counter;
    }
}

解释：

@GetMapping("/generateId")：将 generateId 方法映射到 /generateId 路径。
synchronized：保证同一时刻只有一个线程可以执行 generateId 方法，避免多个线程同时执行生成编号的逻辑，防止生成相同的编号。

（二）使用 `ReentrantLock`

使用 ReentrantLock 可以实现更灵活的锁控制：

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class SampleController {

    private int counter = 0;
    private final Lock lock = new ReentrantLock();

    @GetMapping("/generateId")
    public String generateId() {
        lock.lock();
        try {
            // 生成编号的逻辑
            counter++;
            return "ID-" + counter;
        } finally {
            lock.unlock();
        }
    }
}

解释：

private final Lock lock = new ReentrantLock();：创建一个可重入锁。
lock.lock();：获取锁。
try 块内是临界区，执行生成编号的逻辑。
finally 块中 lock.unlock(); 确保锁最终会被释放，防止死锁。

二、使用分布式锁

对于多实例部署，使用分布式锁可以保证多个实例之间的并发控制。可以使用 Redis 或 ZooKeeper 实现分布式锁。

（一）使用 Redis 实现分布式锁

首先，添加 Redis 依赖：

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>

然后，使用 Redis 实现分布式锁：

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;
import java.util.UUID;
import java.util.concurrent.TimeUnit;

@RestController
public class SampleController {

    @Autowired
    private StringRedisTemplate redisTemplate;

    @GetMapping("/generateId")
    public String generateId() {
        String lockKey = "generateIdLock";
        String requestId = UUID.randomUUID().toString();
        try {
            Boolean success = redisTemplate.opsForValue().setIfAbsent(lockKey, requestId, 10, TimeUnit.SECONDS);
            if (success == null ||!success) {
                throw new RuntimeException("Failed to acquire lock");
            }
            // 生成编号的逻辑
            int counter = (int) redisTemplate.opsForValue().increment("counter", 1);
            return "ID-" + counter;
        } finally {
            if (requestId.equals(redisTemplate.opsForValue().get(lockKey))) {
                redisTemplate.delete(lockKey);
            }
        }
    }
}

解释：

@Autowired StringRedisTemplate redisTemplate;：注入 Redis 操作模板。
String lockKey = "generateIdLock";：定义锁的键。
String requestId = UUID.randomUUID().toString();：生成一个唯一的请求 ID。
redisTemplate.opsForValue().setIfAbsent(lockKey, requestId, 10, TimeUnit.SECONDS);：尝试设置锁，设置过期时间为 10 秒。
redisTemplate.opsForValue().increment("counter", 1);：使用 Redis 的原子操作生成唯一编号。
在 finally 块中，检查锁是否属于当前请求，若是则删除锁，防止死锁。

（二）使用 Redisson 实现分布式锁

添加 Redisson 依赖：

<dependency>
    <groupId>org.redisson</groupId>
    <artifactId>redisson-spring-boot-starter</artifactId>
    <version>3.17.0</version>
</dependency>

使用 Redisson 实现分布式锁：

import org.redisson.api.RLock;
import org.redisson.api.RedissonClient;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class SampleController {

    @Autowired
    private RedissonClient redissonClient;

    @GetMapping("/generateId")
    public String generateId() {
        RLock lock = redissonClient.getLock("generateIdLock");
        try {
            lock.lock();
            // 生成编号的逻辑
            int counter = (int) redisTemplate.opsForValue().increment("counter", 1);
            return "ID-" + counter;
        } finally {
            lock.unlock();
        }
    }
}

解释：

@Autowired RedissonClient redissonClient;：注入 Redisson 客户端。
RLock lock = redissonClient.getLock("generateIdLock");：获取分布式锁。
lock.lock();：加锁。
在 finally 块中 lock.unlock(); 解锁。

三、使用数据库的唯一约束

可以利用数据库的唯一约束来保证编号的唯一性。

（一）使用数据库的自增主键

如果使用数据库（如 MySQL）存储编号，可以使用自增主键：

CREATE TABLE ids ( id INT AUTO_INCREMENT PRIMARY KEY, data VARCHAR(255) );

在 Spring Boot 中：

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class SampleController {

    @Autowired
    private JdbcTemplate jdbcTemplate;

    @GetMapping("/generateId")
    public String generateId() {
        int generatedId = jdbcTemplate.queryForObject("INSERT INTO ids (data) VALUES ('example') RETURNING id", Integer.class);
        return "ID-" + generatedId;
    }
}

解释：

@Autowired JdbcTemplate jdbcTemplate;：注入 JdbcTemplate。
jdbcTemplate.queryForObject("INSERT INTO ids (data) VALUES ('example') RETURNING id", Integer.class);：插入数据并返回自增的 id。

（二）使用 UUID 作为编号

使用 UUID 可以避免重复编号，无需加锁：

import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;
import java.util.UUID;

@RestController
public class SampleController {

    @GetMapping("/generateId")
    public String generateId() {
        return UUID.randomUUID().toString();
    }
}

解释：

UUID.randomUUID().toString();：生成一个唯一的 UUID 作为编号。

四、使用并发容器

使用 AtomicInteger 等并发容器：

import java.util.concurrent.atomic.AtomicInteger;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class SampleController {

    private final AtomicInteger counter = new AtomicInteger(0);

    @GetMapping("/generateId")
    public String generateId() {
        return "ID-" + counter.incrementAndGet();
    }
}

解释：