Java.Utils：生成不重复的编号

Don’t say much, just go to the code.

package org.bood.common.utils;

import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.ThreadLocalRandom;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicInteger;

/**
 * 用于生成各种类型的唯一ID。
 *
 * @author bood
 * @since 2024/08/30
 */
public class UniqueIDGenerator {

    /**
     * 定义时间戳格式为 "yyyyMMddHHmmss"
     */
    private static final DateTimeFormatter TIMESTAMP_FORMATTER = DateTimeFormatter.ofPattern("yyyyMMddHHmmss");
    /**
     * 定义一个原子整数，初始值为1
     */
    private static final AtomicInteger ATOMIC_INTEGER = new AtomicInteger(1);

    private UniqueIDGenerator() {
    }

    /**
     * 生成一种唯一ID的格式，包含时间戳、哈希码和原子计数
     *
     * @param lock 用于生成哈希码的字符串
     * @return 生成的唯一ID字符串
     * @author bood
     * @since 2024/08/30
     */
    public static String generateUniqueIDWithTimestamp(String lock) {
        // 获取当前时间戳
        String timestamp = getCurrentTimestamp();
        // 获取输入字符串的正哈希码
        int hashCode = getPositiveHashCode(lock);
        // 获取下一个原子计数
        int atomicNum = getNextAtomicInteger();

        // 拼接时间戳、哈希码和原子计数形成唯一ID
        return timestamp + hashCode + atomicNum;
    }

    /**
     * 生成另一种唯一ID的格式，包含随机数、哈希码和填充的原子计数
     *
     * @param lock 用于生成哈希码的字符串
     * @return 生成的唯一ID字符串
     * @author bood
     * @since 2024/08/30
     */
    public static String generateUniqueIDWithRandom(String lock) {
        // 生成0至999的随机数
        int randomNum = ThreadLocalRandom.current().nextInt(0, 1000);
        // 获取输入字符串的正哈希码
        int hashCode = getPositiveHashCode(lock);
        // 获取填充至三位的原子计数
        String paddedAtomicNum = String.format("%03d", getNextAtomicInteger());

        // 拼接随机数、哈希码和填充的原子计数形成唯一ID
        return randomNum + hashCode + paddedAtomicNum;
    }

    /**
     * 获取当前时间戳字符串
     */
    private static String getCurrentTimestamp() {
        return LocalDateTime.now().format(TIMESTAMP_FORMATTER);
    }

    /**
     * 获取输入字符串的正哈希码
     */
    private static int getPositiveHashCode(String input) {
        return Math.abs(input.hashCode());
    }

    /**
     * 获取下一个原子计数
     */
    private static int getNextAtomicInteger() {
        return ATOMIC_INTEGER.getAndIncrement();
    }

    public static void main(String[] args) {
        // 创建一个线程池，假设我们需要同时生成10个ID
        ExecutorService executor = Executors.newFixedThreadPool(10);

        for (int i = 0; i < 10; i++) {
            // 每个线程使用不同的lock字符串
            final String lock = "lockString" + i;
            executor.execute(() -> {
                // 调用时间戳生成ID
                String idWithTimestamp = UniqueIDGenerator.generateUniqueIDWithTimestamp(lock);
                // 调用随机数生成ID
                String idWithRandom = UniqueIDGenerator.generateUniqueIDWithRandom(lock);

                // 打印生成的ID
                System.out.println("ID with Timestamp: " + idWithTimestamp);
                System.out.println("ID with Random: " + idWithRandom);
            });
        }

        // 关闭线程池，等待所有任务完成
        executor.shutdown();
        try {
            // 等待最多1分钟，如果未完成则强制关闭
            if (!executor.awaitTermination(1, TimeUnit.MINUTES)) {
                executor.shutdownNow();
            }
        } catch (InterruptedException e) {
            executor.shutdownNow();
        }
    }
    
}