Uuid、数据库自增、雪花算法、基于redis自研等数据库唯一ID生成策略对比_springboot自动雪花算法生成id-程序员宅基地

技术标签：算法 java

Uuid、数据库自增、雪花算法、基于redis自研等数据库唯一ID生成策略对比
使用环境
分布式、高并发下全局唯一，趋势递增，效率高，控制并发

先直接上个对比图吧，下面大量干货警告

一、Uuid（java1.5后自带生成工具类）
Uuid是按照开放软件基金会(osf)制定的标准计算用到了以太网开地址(MAC),纳米级时间,芯片id码和许多可能的数字优点:
使用简单
不依赖其他组件
不影响数据库拓展

缺点:
数据库索引效率低
太过于无意义.用户不友好
长度36的字符串,空间占用大
应用集群环境,机器多的时候,重复几率大

使用方法

import java.util.UUID;

public class UTest {
    public static void main(String[] args) {
        UUID uuid = UUID.randomUUID();//生成的类型为uuid类型
        String s = UUID.randomUUID().toString();//经过toString后可直接赋值到id上实现存储
        System.out.println(uuid);
        System.out.println(s);
    }
}

也可以适当的自定义内容

public class UUIDGenerator { 
    public UUIDGenerator() { 
    } 
    /** 
     * 获得一个UUID 
     * @return String UUID 
     */ 
    public static String getUUID(){ 
        String s = UUID.randomUUID().toString(); 
        //去掉“-”符号 
        return s.substring(0,8)+s.substring(9,13)+s.substring(14,18)+s.substring(19,23)+s.substring(24); 
    } 
    /** 
     * 获得指定数目的UUID 
     * @param number int 需要获得的UUID数量 
     * @return String[] UUID数组 
     */ 
    public static String[] getUUID(int number){ 
        if(number < 1){ 
            return null; 
        } 
        String[] ss = new String[number]; 
        for(int i=0;i<number;i++){ 
            ss[i] = getUUID(); 
        } 
        return ss; 
    } 
    public static void main(String[] args){ 
        String[] ss = getUUID(10); 
        for(int i=0;i<ss.length;i++){ 
            System.out.println(ss[i]); 
        } 
    } 
}

二、数据库自增
Mysql 整型自增索引之所以快是因为mysql 采用b+树对整型进行了加速
Mysql使用auto_increment, oracle使用sequence序列
集群环境下,不同的库,设置不同的初始值,每次自增加 100
Mysql下修改起点和步长的方式

设置起点
    Set @@auto_increment_offset=1 // 设置起点为1

设置步长
    Set@@auto_increment_increment=100 // 设置步长为100

查看参数
    show VARIABLES like 'auto_%' // 查看参数

优点:
无需编码
性能也过得去
索引友好

缺点:
大表不能做水平分表,否则插入删除易出现问题(已经存在很大数据的时候再分表,容易出现问题)
依赖前期规划,拓展麻烦
依赖mysql内部维护自增锁,高并发下插入数据影响性能
在业务操作父,子(关联表)插入时,要先父表后子表

相对于uuid 其实数据库自增表的效率稍低
特点是 : 互斥排他可重入

CREATE TABLE TABLE_1
 ( ID INT UNSIGNED NOT NULL PRIMARY KEY AUTO_INCREMENT, // ID列为无符号整型，该列值不可以为空，并不可以重复，而且自增。 
NAME VARCHAR(5) NOT NULL ) 
 AUTO_INCREMENT = 100;

三、雪花算法（snowflake算法）
Snowfake算法是twitter’开源的分布式id生成算法,结果就是long长整型的id
优点:
性能较优,速度快
无需第三方依赖,实现也简单
可以根据实际情况调整和拓展算法,方便灵活 (开源)

缺点:
依赖时间机器,如果发生回拨会导致生成id重复,业界使用一般是根据雪花算法进行拓展的
(可以把这个服务单独做成一个服务用于生成id,但是会连累生成效率)

源码

package com.cnblogs.util;

/**
 * Twitter_Snowflake<br>
 * SnowFlake的结构如下(每部分用-分开):<br>
 * 0 - 0000000000 0000000000 0000000000 0000000000 0 - 00000 - 00000 - 000000000000 <br>
 * 1位标识，由于long基本类型在Java中是带符号的，最高位是符号位，正数是0，负数是1，所以id一般是正数，最高位是0<br>
 * 41位时间戳(毫秒级)，注意，41位时间戳不是存储当前时间的时间戳，而是存储时间戳的差值（当前时间戳 - 开始时间戳)
 * 得到的值），这里的的开始时间戳，一般是我们的id生成器开始使用的时间，由我们程序来指定的（如下下面程序IdWorker类的startTime属性）。41位的时间戳，可以使用69年，年T = (1L << 41) / (1000L * 60 * 60 * 24 * 365) = 69<br>
 * 10位的数据机器位，可以部署在1024个节点，包括5位datacenterId和5位workerId<br>
 * 12位序列，毫秒内的计数，12位的计数顺序号支持每个节点每毫秒(同一机器，同一时间戳)产生4096个ID序号<br>
 * 加起来刚好64位，为一个Long型。<br>
 * SnowFlake的优点是，整体上按照时间自增排序，并且整个分布式系统内不会产生ID碰撞(由数据中心ID和机器ID作区分)，并且效率较高，经测试，SnowFlake每秒能够产生26万ID左右。
 */
public class SnowflakeIdWorker {

    // ==============================Fields===========================================
    /** 开始时间截 (201-01-01) */
    private final long twepoch = 1514736000000L;

    /** 机器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;

    //==============================Constructors=====================================
    /**
     * 构造函数
     * @param workerId 工作ID (0~31)
     * @param datacenterId 数据中心ID (0~31)
     */
    public SnowflakeIdWorker(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;
    }

    // ==============================Methods==========================================
    /**
     * 获得下一个ID (该方法是线程安全的)
     * @return SnowflakeId
     */
    public 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;
    }

    /**
     * 阻塞到下一个毫秒，直到获得新的时间戳
     * @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();
    }

    //==============================Test=============================================
    /** 测试 */
    public static void main(String[] args) {
        SnowflakeIdWorker idWorker = new SnowflakeIdWorker(0, 0);
        for (int i = 0; i < 10; i++) {
            long id = idWorker.nextId();
            System.out.println(Long.toBinaryString(id));
            System.out.println(id);
        }
    }
}

代码简单，但是在分布式系统使用的时候有一些问题：

不同服务器如何使用不同workId，datacenterId？

该类设置为单例初始化？

解决办法如下：

该微服务启动的时候，workId和datacenterId作为参数传入

使用Component注解，将SnowflakeIdWorker类设为单例初始化

package com.cnblogs;

import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.exception.ExceptionUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.data.redis.core.ValueOperations;
import org.springframework.data.redis.serializer.StringRedisSerializer;
import org.springframework.stereotype.Component;
import tech.fullink.eaglehorn.lzfentrance.util.SnowflakeIdWorker;

import javax.annotation.PostConstruct;
import java.util.Set;
import java.util.concurrent.TimeUnit;

/**
 * @author
 * Date: 2018/10/26
 * Time: 17:00:35
 */
@Slf4j
@Component
public class SnowflakeComponent {
    @Value("${server.datacenterId}")
    private long datacenterId;

    @Value("${server.workId}")
    private long workId;


    private static volatile SnowflakeIdWorker instance;

    public SnowflakeIdWorker getInstance() {
        if (instance == null) {
            synchronized (SnowflakeIdWorker.class) {
                if (instance == null) {
                    log.info("when instance, workId = {}, datacenterId = {}", workId, datacenterId);
                    instance = new SnowflakeIdWorker(workId, datacenterId);
                }
            }
        }
        return instance;
    }
}

调用代码

package com.cnflogs;

import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.RestController;
import com.cnflogs.SnowflakeComponent;

/**
 * @author
 */
@Slf4j
@RestController
public class TestController {


    @Autowired
    private SnowflakeComponent snowflakeComponent;

    /**
     * 获取订单号
     *
     * @return
     */
    @RequestMapping(value = "order/no", method = RequestMethod.GET)
    long getOrderNo() {
        return snowflakeComponent.getInstance().nextId();
    }
}

我们用的是spring boot，对应的配置文件bootstrap.yml配置如下：注意要传递的参数配置一定要放在bootstrap.yml里面，而不是application.yml

###################### server info #####################
server:
  port: 10000
  ssl:
    enabled: false
  error:
    whitelabel:
      enabled: false
  workId: 0
  datacenterId: 0 #雪花算法的数据中心id，在java 启动命令中定义，四台为0，1，2，3

spring:
  application:
    name:test

启动方式：

java -jar -Xms256m -Xmx512m -Dserver.workId=1 -Dserver.datacenterId=1 /home/admin/jars/test.jar

不同的服务器 -Dserver.workId -Dserver.datacenterId设置为不同的值。

这样就能正常使用了。

四、基于Redis自研等数据库唯一id策略
Java 中基本类型所占的字节
Oracle 产生序列号的方式
利用增长计数api,业务系统在自增长的基础上,配合其他信息组成一个唯一id
Redis的incr(key) api用于将key的值进行递增,并返回增长数值
如果key不存在,则创建并赋值为0

利用redis的特性: 单线程原子操作,自增计数api,数据有效机制ex

实例
业务编码+地区+自增数值

key的命名规范
系统名:+ 模块:+ 功能: + key 例如: 163:study:order:id

优点:
拓展性强,可以方便的结合业务进行处理
利用redis操作原子性的特征,可以保证在并发的时候不会重复

缺点:
引入redis就意味着引入其他三方依赖
增加一侧网络开销
需要对reids服务实现高可用

高可用
自动分片
哨兵模式

注意: 集群并不能做高可用,因为redis集群中没有选举机制,所以需要采用哨兵(选举的机制)的机制配置高可用
利用springboot整个redis
pom文件

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
 
    <groupId>com.example</groupId>
    <artifactId>demo</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <packaging>jar</packaging>
 
    <name>demo</name>
    <description>Demo project for Spring Boot</description>
 
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>1.5.8.RELEASE</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>
 
    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
        <java.version>1.8</java.version>
    </properties>
 
    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-redis</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
 
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <optional>true</optional>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
    </dependencies>
 
    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>
 
 
</project>

yml文件

spring:
  application:
    name: redis-demo
  redis:
    database: 0
    host: 127.0.0.1
    port: 6379
    timeout: 0  # 连接超时时间（毫秒）
    pool:
      max-active: 20 # 连接池最大连接数（使用负值表示没有限制）
      max-idle: 20  # 连接池中的最大空闲连接
      max-wait: -1 # 连接池最大阻塞等待时间（使用负值表示没有限制）
      min-idle: 0 # 连接池中的最小空闲连接
server:
  port: 8080
  servlet:
    context-path: /redis-demo

Redis config 配置

package com.example.demo.config;
 
import com.fasterxml.jackson.annotation.JsonAutoDetect;
import com.fasterxml.jackson.annotation.PropertyAccessor;
import com.fasterxml.jackson.databind.ObjectMapper;
import org.springframework.cache.CacheManager;
import org.springframework.cache.annotation.CachingConfigurerSupport;
import org.springframework.cache.interceptor.KeyGenerator;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.cache.RedisCacheManager;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.data.redis.serializer.Jackson2JsonRedisSerializer;
 
import java.util.Arrays;
 
/**
 * @Title: redis配置类
 * @Package RedisConfig
 * redis配置类
 * @author syliu
 * @create 2017/9/29 0029
 */
@Configuration
public class RedisConfig {
 
 
    @Bean
    public RedisTemplate<String, String> redisTemplate(RedisConnectionFactory factory) {
        StringRedisTemplate template = new StringRedisTemplate(factory);
        Jackson2JsonRedisSerializer jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer(Object.class);
        ObjectMapper objectMapper = new ObjectMapper();
        objectMapper.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
        objectMapper.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
        jackson2JsonRedisSerializer.setObjectMapper(objectMapper);
        template.setValueSerializer(jackson2JsonRedisSerializer);
        template.afterPropertiesSet();
        return template;
    }
 
 
}

生成方式

package com.example.demo.service;
 
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Service;
 
import java.util.Calendar;
import java.util.Date;
 
/**
 * @author syliu
 * 利用redis生成数据库全局唯一性id
 */
@Service
public class PrimaryKeyService {
 
    @Autowired
    private RedisTemplate redisTemplate;
 
    /**
     * 获取年的后两位加上一年多少天+当前小时数作为前缀
     * @param date
     * @return
     */
    public String getOrderIdPrefix(Date date) {
        Calendar calendar = Calendar.getInstance();
        calendar.setTime(date);
        int year = calendar.get(Calendar.YEAR);
        int month = calendar.get(Calendar.MONTH);
        int day = calendar.get(Calendar.DAY_OF_MONTH);
        int hour = calendar.get(Calendar.HOUR_OF_DAY);
        //补两位,因为一年最多三位数
        String monthFormat = String.format("%1$02d", month+1);
        //补两位，因为日最多两位数
        String dayFormat = String.format("%1$02d", day);
        //补两位，因为小时最多两位数
        String hourFormat = String.format("%1$02d", hour);
        return year + monthFormat + dayFormat+hourFormat;
    }
 
    /**
     * 生成订单
     * @param prefix
     * @return
     */
    public Long orderId(String prefix) {
        String key = "DEMO_ORDER_ID_" + prefix;
        String orderId = null;
        try {
            Long increment = redisTemplate.opsForValue().increment(key,1);
            //往前补6位
            orderId=prefix+String.format("%1$06d",increment);
        } catch (Exception e) {
            System.out.println("生成订单号失败");
            e.printStackTrace();
        }
        return Long.valueOf(orderId);
    }
}

测试类

package com.example.demo;
 
import com.example.demo.service.PrimaryKeyService;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit4.SpringRunner;
 
import java.util.Date;
@RunWith(SpringRunner.class)
@SpringBootTest
public class DemoApplicationTests {
    @Autowired
    private PrimaryKeyService primaryKeyService;
 
    @Test
    public void contextLoads() {
        long startMillis = System.currentTimeMillis();
        String orderIdPrefix = primaryKeyService.getOrderIdPrefix(new Date());
        for (int i = 0; i < 10; i++) {
            Long aLong = primaryKeyService.orderId(orderIdPrefix);
            System.out.println(aLong);
        }
        long endMillis = System.currentTimeMillis();
        System.out.println("生成速度:"+(endMillis-startMillis)+",单位毫秒");
    }
 
}

主要资料来自参考
https://blog.csdn.net/qq_35977237/article/details/84338473
https://blog.csdn.net/kai3123919064/article/details/88771395
https://www.cnblogs.com/cs99lzzs/p/9869414.html

本文链接：https://blog.csdn.net/meishibuyaodarao/article/details/117418006

原作者删帖不实内容删帖广告或垃圾文章投诉

智能推荐

初探Java Nashorn脚本引擎-程序员宅基地

文章浏览阅读4.7k次。要想让一个程序功能变得灵活起来，那么配置绝对是不可或缺的，通过合理的设计，将所有动态变量都配置化，可以最大程度上让程序变得灵活。可是在某些复杂的业务场景中，仅仅只是变量的配置化，往往还并不能满足需求，尤其是互联网这种业务需要快速更迭的行业。于是，做一个这样的功能：仅仅依靠配置，就能让程序的逻辑cover住所有的业务逻辑变化，就成为了程序员的终极梦想。然而，现实是残酷的，"write once run forevre"，这几乎是不可能实现的梦想(如果真的出现了这样的技术，那可能会是我们职业生涯将要面对的最_nashorn

【CTF】用python PIL将RGB值转化为图片_ctf 三个坐标值转换图像-程序员宅基地

文章浏览阅读1.5w次，点赞4次，收藏28次。一道关于ctf的题，用python将rgb值转化为图片_ctf 三个坐标值转换图像

海思HI35xx平台软件开发快速入门之背景知识-程序员宅基地

文章浏览阅读1.4k次。前言：安防领域最近几年可谓暗流涌动，作为安防业的双寡头，大华股份与海康威视凭借行业的东风，两家公司的成长速度异常强劲，在国际市场上已经和应用厂家进行厮杀。 2015年两家公司双双晋升“全球安放50强”，海康排名第二，大华排名第五。以华为海思为代表国产芯片解决方案不断走强，在国际竞争中优势凸显，在后端NVR高端产品线先后推出了海思3531、海思3535、海思3536，同时针对低端的产品线也不..._海思hi35xx平台软件开发快速入门之背景知识

计算机组成原理复习资料_一个地址只能对应输入输出设备-程序员宅基地

文章浏览阅读2.6k次，点赞3次，收藏27次。复习资料一、单项选择题1 CRT的颜色数为真彩色，则它的颜色位是_________。A、24位 B、8位 C、16位 D、32位答案:A2 一个节拍脉冲持续的时间长短是_________。A、指令周期 B、机器周期 C、时钟周期 D、以上都不是答案:C3 CPU组成中不包括_________。A、指令寄存器 B、地址寄存器 C、指令译码器 D、地..._一个地址只能对应输入输出设备

值得收藏【Markdown】皇额娘级教你玩转vscode插件： Markdown All in One_vscode markdown all in one-程序员宅基地

文章浏览阅读2.5k次，点赞2次，收藏2次。vscode中的Markdown All in One插件目前下载量：6,103,710，实力水平轻而易举的可以看出来了，相比于大名鼎鼎的Typora最大的良心优势就是free!free!free!对于穷苦人来说是极好的，赞~~~截至目前最新版本：v3.5.1。_vscode markdown all in one

Linux 命令-程序员宅基地

文章浏览阅读840次，点赞17次，收藏18次。linux命令及网络配置

随便推点

数据结构java版本队列，链表，栈_javal链表 top还是front-程序员宅基地

文章浏览阅读134次。数据结构和算法的关系数据结构是一门研究组织数据方式的学科，程序=数据结构+算法数据结构是算法的基础数据结构结构：线性结构：数组，队列，链表，栈顺序存储结构链式存储结构非线性结构：二维数组，多维数组，广义表，树，图稀疏数组的概念当一个数组中大部分元素为0时，或者为同一个值的数组时，可以使用记录数组一共有几行几列，有多少个不同的数值把具有不同值的元素的行列及值记录在一个小规模的数组中，从而缩小程序的规模二维数组转为稀疏数组：遍历原始的二维数组，得到有效数据的个数sum_javal链表 top还是front