论数据库设计选择一个有序的ID的方法和重要性

一、数据库自增

我们做数据库建表的时候，往往会考虑ID主键怎么定义，之前通常我们都用数据库自增即可，这个不失为一个好办法。但是也会有问题，比如
大型分布式系统，订单分库，那么就比较难保证ID唯一了，并且太过依赖于数据库，ID比较容易被猜测到，所以对于大型系统，一般不建议自增。

二、UUID

有些人会想，那么如果要保证唯一的话，直接用UUID它不香么，全球唯一，但是这里也有很大的弊端，首先UUID长度过长，用来做ID主键会浪费存储空间，当做索引页会浪费太大的空间，
其次，UUID会暴露MAC地址，并且最主要的是UUID无序，如果要做排序，那么只能靠别的字段,因此这里也不建议UUID

三、雪花算法

雪花算法是有序的，并且机器ID不同的话单线程唯一。这里强烈推荐，我们可以对雪花算法进行一些修改，对其加上redis分布式锁，那么就可以保证
绝对唯一啦。完美。雪花算法+Redis分布式锁思路如下：

1、对雪花算法进行改造，取ID的时候进行方法加同步锁：synchronized ,这个的好处是可以在同一个进程中，所有线程取的ID不同。
2、第一步只是控制了同一个进程的唯一性，那么假如是多个进程呢，此时就需要继续对雪花算法进行改造，获取ID的方法里面使用Redis分布式锁来处理。
3、不同进程的线程进入取ID的方法，先对一个key进行setNx设置值，超时时间为三分钟，如果设置成功，则表明获取到锁，可以进入获取一个id，获取成功后移除key。若是设置失败，也就是返回0，则进行休眠Sleep(30)毫秒，这个可以具体情况调整，再次调用获取的方法（相当于递归循环），此时若锁被释放，则将设置成功。

大概思路如上，当然最简单的还是不同应用启动的时候，设置不同的工作机器ID（0~31）和数据中心ID（0~31），若是有上万台服务器，那么
就避免不了，机器ID相同情况下，那么我们再相同的机器ID那一批应用，就可以结合雪花算法+Redis分布式锁来完美解决。

下面给出Java版本一个雪花算法例子：不包括Redis分布式锁

public class SnowflakeIdUtil {
    // ==============================Fields===========================================
    /** 开始时间截 (2015-01-01) */
    private final long twepoch = 1420041600000L;
    /** 机器id所占的位数 */
    private final long workerIdBits = 5L;
    /** 数据标识id所占的位数 */
    private final long datacenterIdBits = 5L;
    /** 支持的最大机器id，结果是31 (这个移位算法可以很快的计算出几位二进制数所能表示的最大十进制数) */
    private final long maxWorkerId = -1L ^ (-1L << workerIdBits);
    /** 支持的最大数据标识id，结果是31 */
    private final long maxDatacenterId = -1L ^ (-1L << datacenterIdBits);
    /** 序列在id中占的位数 */
    private final long sequenceBits = 12L;
    /** 机器ID向左移12位 */
    private final long workerIdShift = sequenceBits;
    /** 数据标识id向左移17位(12+5) */
    private final long datacenterIdShift = sequenceBits + workerIdBits;
    /** 时间截向左移22位(5+5+12) */
    private final long timestampLeftShift = sequenceBits + workerIdBits + datacenterIdBits;
    /** 生成序列的掩码，这里为4095 (0b111111111111=0xfff=4095) */
    private final long sequenceMask = -1L ^ (-1L << sequenceBits);
    /** 工作机器ID(0~31) */
    private long workerId;
    /** 数据中心ID(0~31) */
    private long datacenterId;
    /** 毫秒内序列(0~4095) */
    private long sequence = 0L;
    /** 上次生成ID的时间截 */
    private long lastTimestamp = -1L;
    private static SnowflakeIdUtil idWorker;
    /**
     * 以SnowFlake算法，获取唯一有序id
     * @return
     */
    public static long getSnowflakeId() {
        if(idWorker == null) {
            synchronized (SnowflakeIdUtil.class) {
                if(idWorker == null) {
                    idWorker = new SnowflakeIdUtil(0, 0);
                }
            }
        }
        return idWorker.nextId();
    }
    // ==============================Methods==========================================
   private SnowflakeIdUtil() {
    }
    //==============================Constructors=====================================
    /**
     * 构造函数
     * @param workerId 工作ID (0~31)
     * @param datacenterId 数据中心ID (0~31)
     */
    private SnowflakeIdUtil(long workerId, long datacenterId) {
        if (workerId > maxWorkerId || workerId < 0) {
            throw new IllegalArgumentException(String.format("worker Id can't be greater than %d or less than 0", maxWorkerId));
        }
        if (datacenterId > maxDatacenterId || datacenterId < 0) {
            throw new IllegalArgumentException(String.format("datacenter Id can't be greater than %d or less than 0", maxDatacenterId));
        }
        this.workerId = workerId;
        this.datacenterId = datacenterId;
    }
    /**
     * 阻塞到下一个毫秒，直到获得新的时间戳
     * @param lastTimestamp 上次生成ID的时间截
     * @return 当前时间戳
     */
    protected long tilNextMillis(long lastTimestamp) {
        long timestamp = timeGen();
        while (timestamp <= lastTimestamp) {
            timestamp = timeGen();
        }
        return timestamp;
    }
    /**
     * 返回以毫秒为单位的当前时间
     * @return 当前时间(毫秒)
     */
    protected long timeGen() {
        return System.currentTimeMillis();
    }
    /**
     * 获得下一个ID (该方法是线程安全的)
     * @return SnowflakeId
     */
    protected synchronized long nextId() {
        long timestamp = timeGen();
        //如果当前时间小于上一次ID生成的时间戳，说明系统时钟回退过这个时候应当抛出异常
        if (timestamp < lastTimestamp) {
            throw new RuntimeException(
                    String.format("Clock moved backwards.  Refusing to generate id for %d milliseconds", lastTimestamp - timestamp));
        }
        //如果是同一时间生成的，则进行毫秒内序列
        if (lastTimestamp == timestamp) {
            sequence = (sequence + 1) & sequenceMask;
            //毫秒内序列溢出
            if (sequence == 0) {
                //阻塞到下一个毫秒,获得新的时间戳
                timestamp = tilNextMillis(lastTimestamp);
            }
        }
        //时间戳改变，毫秒内序列重置
        else {
            sequence = 0L;
        }
        //上次生成ID的时间截
        lastTimestamp = timestamp;
        //移位并通过或运算拼到一起组成64位的ID
        return ((timestamp - twepoch) << timestampLeftShift) //
                | (datacenterId << datacenterIdShift) //
                | (workerId << workerIdShift) //
                | sequence;
    }
    public static void main(String[] args) {
        long snowflakeId = getSnowflakeId();
        System.out.println(snowflakeId);
    }
}

总结：单体应用采用雪花算法完美解决ID问题，大一点十几二十个节点的采用雪花算法+Redis锁完美解决，上万的服务器应用建议采用机器ID，操作ID+雪花算法+Redis分布式锁。有顺序的ID
可以在排序的时候完全根据ID来升序或降序，不建议用时间日期字段。

纯属个人观点，有什么误区或者不足之处麻烦各位同行指教指教，或者有什么更好的建议分享出来学习学习。