基于Redis实现分布式全局唯一且递增效果的ID

package tech.foolfish.demo.utils;

import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;
import java.util.concurrent.TimeUnit;

import org.redisson.Redisson;
import org.redisson.api.RAtomicLong;
import org.redisson.api.RedissonClient;
import org.redisson.config.Config;
import org.springframework.stereotype.Component;

class DistributedUniqueIdGenerator {

    private static final String REDIS_HOST = "xxxxxx";
    private static final int REDIS_PORT = 6379;
    private static final String REDIS_PWD = "xxxxxx";
    private static final String ID_PREFIX = "timestamp_";
    private static final String ID_SUFFIX = "_increment";

    private RedissonClient redissonClient;

    public DistributedUniqueIdGenerator() {
        // 创建 Redisson 客户端配置
        Config config = new Config();
        config.useSingleServer().setAddress("redis://" + REDIS_HOST + ":" + REDIS_PORT);
        config.useSingleServer().setPassword(REDIS_PWD);
        config.useSingleServer().setDatabase(1);

        // 创建 Redisson 客户端
        redissonClient = Redisson.create(config);
    }

    public String generateUniqueId() {
        try {
            LocalDateTime now = LocalDateTime.now();
            String timestamp = now.format(DateTimeFormatter.ofPattern("yyyyMMddHHmmss"));

            // 获取当前时间戳的原子递增数
            RAtomicLong atomicLong = redissonClient.getAtomicLong(ID_PREFIX + timestamp + ID_SUFFIX);
            atomicLong.expireAsync(5, TimeUnit.MINUTES);
            Long increment = atomicLong.incrementAndGet();

            return timestamp + increment;
        } catch (Exception e) {
            e.printStackTrace();
            throw new RuntimeException("Failed to generate unique ID");
        }
    }
}

package tech.foolfish.demo.utils;

import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.parallel.Execution;
import org.junit.jupiter.api.parallel.ExecutionMode;

class DistributedUniqueIdGeneratorTest {

    void testGenerateUniqueId1() {
        DistributedUniqueIdGenerator generator = new DistributedUniqueIdGenerator();

        // 生成多个唯一 ID 并验证递增规律
        List<String> ids = new ArrayList<>();
        for (int i = 0; i < 10; i++) {
            String uniqueId = generator.generateUniqueId();
            ids.add(uniqueId);
        }
        System.out.println("Generated IDs: " + ids);
    }

    @Test
    @Execution(ExecutionMode.CONCURRENT)
    public void concurrentTestMethod() throws InterruptedException {
        int numThreads = 10; // 并发线程数
        ExecutorService executor = Executors.newFixedThreadPool(numThreads);

        // 使用 CountDownLatch 等待所有线程执行完毕
        CountDownLatch latch = new CountDownLatch(numThreads);

        for (int i = 0; i < numThreads; i++) {
            executor.execute(() -> {
                testGenerateUniqueId1();
                latch.countDown();
            });
        }

        // 等待所有线程执行完毕
        latch.await();

        executor.shutdown();
    }
}