简易序列号实现

package com.itch;
import java.text.SimpleDateFormat;
import java.util.Calendar;
import java.util.Date;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.concurrent.atomic.AtomicReference;

/**
 * <p> 本类可以简易生成唯一序列号，线程安全<b>【待验证】</b>
 * <p> 序列号可由yyyyMMddHHmmss + [machineId(机器id) + tid(运行线程id)] + index(序号) 等部分组成
 * <p> 实现思路：以当前运行时间，每秒钟先按序分配（从下标0开始）。若当前秒不足以分配，则向未来秒数进行预分配
 * <hr>
 * <em> 仅供学习参考，欢迎大家一起测试，争取能用到生产环境。lol..
 * @author tianchong_01011@163.com
 * @version 0.1
 */
public final class SimpleUniqueNo {
    
    /**
     *     默认每秒可分配序号位数
     */
    public static final int DEFAULT_INDEX_BIT_PER_SECOND = 4;
    
    /**
     *     默认machine id
     */
    public static final String DEFAULT_MACHINE_ID = "00";
    
    /**
     *     计数器
     */
    private volatile AtomicInteger indexCounter;
    
    /**
     *     上一次执行时间
     */
    private volatile Date lastestTime;
    
    /**
     *     超过每秒最大分配时的基准时间
     */
    private AtomicReference<Date> overBaseTime;
    
    /**
     *     日期格式化对象 
     */
    private ThreadLocal<SimpleDateFormat> threadLocal;
    
    /**
     *     预分配最大秒数，主要是为了空闲时重置 {@link #indexCounter}，防止溢出
     */
    private volatile int maxOffset;
    
    /**
     *  int 溢出次数
     */
    private volatile int intOverflowTimes;
    
    /**
     *     每秒可分配序号位数
     */
    private final int indexBitPerSecond;
    
    private final int maxIndexNum;
    
    /**
     *     每秒请求数
     */
    private volatile AtomicInteger threadNumPerSecond;
    
    /**
     *     机器编号
     */
    private final String machineId;
    
    public SimpleUniqueNo() {
        this(DEFAULT_INDEX_BIT_PER_SECOND);
    }
    
    /**
     *     
     * @param indexBitPerSecond 每秒分配位数，由调用者保证位数不会造成interger溢出
     */
    public SimpleUniqueNo(int indexBitPerSecond) {
        this(indexBitPerSecond, DEFAULT_MACHINE_ID);
    }
    
    /**
     * 
     * @param indexBitPerSecond 每秒分配位数，由调用者保证位数不会造成interger溢出
     * @param machineNo    机器号
     */
    public SimpleUniqueNo(int indexBitPerSecond, String machineId) {
        super();
        this.indexCounter = new AtomicInteger();
        this.threadLocal = new ThreadLocal<>();
        this.lastestTime = new Date();
        this.overBaseTime = new AtomicReference<>();
        this.indexBitPerSecond = indexBitPerSecond;
        this.machineId = machineId;
        StringBuilder builder = new StringBuilder("1");
        for (int i=0; i<indexBitPerSecond; i++) {
            builder.append("0");
        }
        this.maxIndexNum = Integer.parseInt(builder.toString());
        this.threadNumPerSecond = new AtomicInteger();
    }
    
    public String genNo() {
        SimpleDateFormat sdf = threadLocal.get();
        if (null == sdf) {
            sdf = new SimpleDateFormat("yyyyMMddHHmmss");
            threadLocal.set(sdf);
        }
        
        Date date = new Date();
        Calendar cd = Calendar.getInstance();
        cd.setTime(date);
        String ns = "" + cd.get(Calendar.YEAR) + cd.get(Calendar.MONTH) + cd.get(Calendar.DAY_OF_MONTH) 
                + cd.get(Calendar.HOUR_OF_DAY) + cd.get(Calendar.MINUTE) + cd.get(Calendar.SECOND);
        cd.setTime(lastestTime);
        String os = "" + cd.get(Calendar.YEAR) + cd.get(Calendar.MONTH) + cd.get(Calendar.DAY_OF_MONTH) 
                + cd.get(Calendar.HOUR_OF_DAY) + cd.get(Calendar.MINUTE) + cd.get(Calendar.SECOND);
        
        int i = indexCounter.get();
        if (i < maxIndexNum && ns.hashCode() != os.hashCode() && lastestTime.before(date)) {    // 新的1s 重置计数  
            synchronized (this) {
                cd.setTime(lastestTime);
                os = "" + cd.get(Calendar.YEAR) + cd.get(Calendar.MONTH) + cd.get(Calendar.DAY_OF_MONTH) 
                        + cd.get(Calendar.HOUR_OF_DAY) + cd.get(Calendar.MINUTE) + cd.get(Calendar.SECOND);
                i = indexCounter.get();
                if (i < maxIndexNum && ns.hashCode() != os.hashCode() && lastestTime.before(date)) {        // 防止更新过期时间
                    Date oldLastestTime = lastestTime;
                    while (threadNumPerSecond.get() > 0) {
                        Thread.yield();
                    }
                    i = indexCounter.get();
                    if ((intOverflowTimes == 0 && i < maxIndexNum)) {    // 非溢出借位 重置  
                        indexCounter.set(0);
                    } else {    // idle reset avoid integer overflow
                        long offset = date.getTime() - oldLastestTime.getTime();
                        if (offset / 1000 > maxOffset) {
                            indexCounter.set(0);
                            intOverflowTimes = 0;
                            maxOffset = 0;
                            overBaseTime.set(null);
                        }
                    }
                    
                    lastestTime = date;
                }
            }
        }
        
        threadNumPerSecond.getAndIncrement();
        int c = indexCounter.getAndIncrement();
        threadNumPerSecond.getAndDecrement();
        if (c < 0) {    // integer overflow
            c = indexCounter.get();
            if (indexCounter.compareAndSet(c, 0)) {
                intOverflowTimes++;
            } else {
                while (indexCounter.get() < 0) {    // waitting
                    // do nothing
                }
            }
            
            c = indexCounter.getAndIncrement();
        }

        if (intOverflowTimes > 0 || c >= maxIndexNum) {    // 溢出借未来时间
            date = overBaseTime.get() != null ? overBaseTime.get() : date;
            cd.setTime(date);
            overBaseTime.compareAndSet(null, date);
            int offset = (c / maxIndexNum) + (Integer.MAX_VALUE / maxIndexNum) * intOverflowTimes;
            cd.add(Calendar.SECOND, offset);
            date = cd.getTime();
            
            maxOffset = Math.max(maxOffset, offset);
            c = c % maxIndexNum;
        }
        
        String time = null, mid = null, tid = null, index = null;
        time = sdf.format(date);
        mid = machineId;
//        tid = "" + Thread.currentThread().getId();
        index = String.format("%0" + indexBitPerSecond + "d", c);
        return time + mid + index;
    }
    
    public static void main(String[] args) {
        // 单机A系统
        SimpleUniqueNo unique = new SimpleUniqueNo();
        System.out.println(unique.genNo());
        // 单机其他系统
//        SimpleUniqueNo unique = new SimpleUniqueNo();
//        System.out.println(unique.genNo());
        
        // 多机
        SimpleUniqueNo u1 = new SimpleUniqueNo(DEFAULT_INDEX_BIT_PER_SECOND, "01");
        SimpleUniqueNo u2 = new SimpleUniqueNo(DEFAULT_INDEX_BIT_PER_SECOND, "02");
        System.out.println(u1.genNo());
        System.out.println(u2.genNo());
    }

}