雪花算法学习及应用

最新推荐文章于 2024-04-16 15:02:19 发布
最新推荐文章于 2024-04-16 15:02:19 发布
阅读量735 收藏 3
点赞数
分类专栏： 笔记 工作记录 文章标签： 学习 java 算法 spring boot spring
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43744387/article/details/127315140
版权

目录

问题需求

1，使用UUID

2，数据库自增主键

3，基于Redis生成全局ID策略

4，雪花算法

雪花算法结构

号段解析

优缺点

源码以下代码仅供学习

雪花算法应用改进

解决方案1

解决方案2

解决方案3

问题需求

在数据库中需要插入一个唯一性的标识，常用目前处理方案

1，使用UUID

UUID(Universally Unique ldentifer)的标准型式包含32个16进制数字，以连了号分为五段，形式为8-4-4-4-12的36个字符， 示例：550e8400-e29b-41d4-a716-446655440000

public class UUIDTest {
    public static void main(String[] args) {
        System.out.println(UUID.randomUUID().toString());
    }
}

 

性能非常高：本地生成，没有网络消耗

如果只是考虑唯一性，那就选用它吧

但是，入数据库性能差

为什么无序的UUID会导致入库性能变差呢？

无序，无法预测他的生成顺序，不能生成递增有序的数字。首先分布式ID一般都会作为主键， 但是安装MySQL官方推荐主键要尽量越短越好，UUID每一个都很长，所以不是很推荐。

主键，ID作为主键时在特定的环境会存在一些问题。比如做DB主键的场景下，UUID就非常不适用MySQL官方有明确的建议主键要尽量越短越好36个字符长度的UUID不符合要求。

索引，既然分布式ID是主键，然后主键是包含索引的，然后MySQL的索引是通过B+树来实现的，每一次新的UUID数据的插入，为了查询的优化，都会对索引底层的B+树进行修改，因为UUID数据是无序的，所以每一次UUID数据的插入都会对主键地械的B+树进行很大的修改，这一点很不好。 插入完全无序，不但会导致一-些中间节点产生分裂，也会白白创造出很多不饱和的节点，这样大大降低了数据库插入的性能。

2，数据库自增主键

单机

在单机里面，数据库的自增ID机制的主要原理是：数据库自增ID和MySQL数据库的replace into实现的。

REPLACE INTO的含义是插入一条记录，如果表中唯一索引的值遇到冲突，则替换老数据。

这里的replace into跟inset功能类似，不同点在于：replace into首先尝试插入数据列表中，如果发现表中已经有此行数据（根据主键或唯一索引判断）则先删除，再插入。否则直接插入新数据。

 

 

CREATE TABLE t_test(
	id BIGINT(20) UNSIGNED NOT NULL AUTO_INCREMENT PRIMARY KEY,
	stub CHAR(1) NOT NULL DEFAULT '',
	UNIQUE KEY stub(stub)
)

SELECT * FROMt_ test;

REPLACE INTO t_test (stub) VALUES('b');

SELECT LAST_INSERT_ID();

集群分布式

那数据库自增ID机制适合作分布式ID吗？答案是不太适合

1：系统水平扩展比较困难，比如定义好了步长和机器台数之后，如果要添加机器该怎么做？假设现在只有一台机器发号是1，2，3，4，5（步长是1），这

个时候需要扩容机器一台。可以这样做：把第二台机器的初始值设置得比第一台超过很多，貌似还好，现在想象一下如果我们线上有100台机器，这

个时候要扩容该怎么做？简直是噩梦，所以系统水平扩展方案复杂难以实现。

2：数据库压力还是很大，每次获取ID都得读写一次数据库， 非常影响性能，不符合分布式ID里面的延迟低和要高QPS的规则（在高并发下，如果都去数据库里面获取id，那是非常影响性能的）

3，基于Redis生成全局ID策略

因为Redis是单线的天生保证原子性，可以使用原子操作INCR和INCRBY来实现

注意：在Redis集群情况下，同样和MySQL一样需要设置不同的增长步长，同时key一定要设置有效期可以使用Redis集群来获取更高的吞吐量。

假如一个集群中有5台Redis。可以初始化每台Redis的值分别是1,2,3,4,5，然后步长都是5。虽然可以实现 但是需要维护reids的集群

各个Redis生成的ID为:

A：1, 6, 11, 16, 21

B：2, 7 , 12, 17, 22

C：3, 8, 13, 18, 23

D：4, 9, 14, 19, 24

E：5, 10, 15, 20, 25

4，雪花算法

在分布式的环境下必须全局且唯一 。

  1. 一般都需要单调递增，因为一般唯一ID都会存到数据库，而Innodb的特性就是将内容存储在主键索引树上的叶子节点而且是从左往右，递增的，所以考
  2. 虑到数据库性能，一般生成的ID也最好是单调递增。 为了防止ID冲突可以使用36位的UUID，但是UUID有一些缺点， 首先他相对比较长， 另外UUID一般是无序的。
  3. 可能还会需要无规则，因为如果使用唯一ID作为订单号这种，为了不然别人知道一天的订单量是多少，就需要这个规则。

雪花算法结构

雪花算法的几个核心组成部分：

 

号段解析

1bit：

不用，因为二进制中最高位是符号位，1表示负数，0表示正数。生成的id一般都是用整数，所以最高位固定为0。

41bit - 时间戳，用来记录时间戳，毫秒级：

  1. 41位可以表示为2的41次方减去1个数字2^{41}-1
  2. 如果只用来表示正整数（计算机中正数包含0），可以表示的数值范围是0到0至 2^{41}-1 ，减1是因为可表示的数值范围是从0开始算的，而不是1。
  3. 也就是说41位可以表示 2^{41}-1个毫秒的值，转化成单位年则是（2^{41}-1）/ (1000∗60∗60∗24∗365)=69年。

10bit - 工作机器ID，用来记录工作机器ID：

  1. 可以部署 2^{10}= 10242 个节点，包括5位DataCenterId和5位Workerld。
  2. 5位(bit) 可以表示的最大正整数是 2^{5}−1=31,即可以用0、1、2、3、…31这32个数字，来表示不同的DataCenterld或Workerld。

注意：我们在分布式中保证雪花算法生成的id不一致，主要就是就是依据DataCenterld和Workerld，后续会用到。

12bit - 序列号，用来记录同毫秒内产生的不同id。

12位(bit) 可以表示的最大正整数是 2^{12} - 1 = 40952 ，即可以用0、1、2、 3、…4094这4095个数字，来表示同一机器同一时间截(毫秒)内产生的4095个ID序号。

SnowFlake可以保证：

所有生成的ID按时间趋势递增。

整个分布式系统内不会产生重复id（因为有DataCenterId和Workerld来做区分)

优缺点

优点：

毫秒数在高位，自增序列在低位，整个ID都是趋势递增的。

不依赖数据库等第三方系统，以服务的方式部署，稳定性更高，生成ID的性能也是非常高的。

可以根据自身业务特性分配bit位，非常灵活。

缺点：

依赖机器时钟，如果机器时钟回拨，会导致重复ID生成。

在单机上是递增的，但是由于设计到分布式环境，每台机器上的时钟不可能完全同步，有时候会出现不是全局递增的情况。

（此缺点可以认为无所谓，一般分布式ID只要求趋势递增，并不会严格要求递增，90%的需求都只要求趋势递增）

源码以下代码仅供学习

/**
 * Twitter_Snowflake
 * SnowFlake的结构如下(每部分用-分开):
 * 0 - 0000000000 0000000000 0000000000 0000000000 0 - 00000 - 00000 - 000000000000
 * 1位标识，由于long基本类型在Java中是带符号的，最高位是符号位，正数是0，负数是1，所以id一般是正数，最高位是0
 * 41位时间戳(毫秒级)，注意，41位时间戳不是存储当前时间的时间戳，而是存储时间戳的差值（当前时间戳 - 开始时间戳)
 * 得到的值），这里的的开始时间戳，一般是我们的id生成器开始使用的时间，由我们程序来指定的（如下面程序SnowflakeIdWorker类的startTime属性）。41位的时间戳，可以使用69年，年T = (1L << 41) / (1000L * 60 * 60 * 24 * 365) = 69
 * 10位的数据机器位，可以部署在1024个节点，包括5位datacenterId和5位workerId
 * 12位序列，毫秒内的计数，12位的计数顺序号支持每个节点每毫秒(同一机器，同一时间戳)产生4096个ID序号
 * 加起来刚好64位，为一个Long型。
 */
public class SnowflakeIdWorker {
    /** 开始时间戳 (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;

    //==============================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();
    }

    /** 测试 */
    public static void main(String[] args) {
        System.out.println("开始："+System.currentTimeMillis());
        SnowflakeIdWorker idWorker = new SnowflakeIdWorker(0, 0);
        for (int i = 0; i < 50; i++) {
            long id = idWorker.nextId();
            System.out.println(id);
//            System.out.println(Long.toBinaryString(id));
        }
        System.out.println("结束："+System.currentTimeMillis());
    }
}

雪花算法应用改进

从上面的源码我们可以看的出来，每次在生成id的时候需要手动的指定工作id和机器id两个值，如果我们的服务部署在两台不同的服务器上面，并且两台服务器上面的服务，生成的id值都放在了同一张表示表中（分布式），而且还要保证唯一（作为主键使用），那么我们的机器id和工作id就不能保持一致，以此来保证id的唯一性，因此我们要在每一个服务器上面确定不一样的DataCenterld和Workerld

解决方案1

我们可以把DataCenterld和Workerld值放在配置文件中，然后手动获取值（实现比较简单，代码就不贴出来了）

解决方案2

我们可以获取到当前服务器的地址作为DataCenterld，我们获取到当前服务器的名称作为Workerld

代码如下：

package com.asinfo.config;




import org.apache.commons.lang3.RandomUtils;
import org.apache.commons.lang3.StringUtils;
import org.apache.commons.lang3.SystemUtils;
import org.slf4j.LoggerFactory;

import java.net.Inet4Address;
import java.net.UnknownHostException;

public class SnowflakeIdWorker {

	// ==============================Fields===========================================
	/** 开始时间截 (2015-01-01) */
	//private final long twepoch = 1489111610226L;
	private final long twepoch = 1665568007832L;

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

	static {
		//获取id之前给工作机器ID和数据中心ID赋值
		idWorker = new SnowflakeIdWorker(getWorkId(),getDataCenterId());
		//idWorker = new SnowflakeIdWorker(33,33);
	}

	//==============================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("workerId can't be greater than %d or less than 0", maxWorkerId));
		}
		if (dataCenterId > maxDataCenterId || dataCenterId < 0) {
			throw new IllegalArgumentException(String.format("dataCenterId 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();
		System.out.println("当前时间戳"+timestamp);

		System.out.println("上一次的时间戳="+lastTimestamp);
		//如果当前时间小于上一次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();
	}

	private static Long getWorkId(){
		try {
			String hostAddress = Inet4Address.getLocalHost().getHostAddress();
			int[] ints = StringUtils.toCodePoints(hostAddress);
			int sums = 0;
			for(int b : ints){
				sums += b;
			}
			return (long)(sums % 32);
		} catch (UnknownHostException e) {
			// 如果获取失败，则使用随机数备用
			return RandomUtils.nextLong(0,31);
		}
	}

	private static Long getDataCenterId(){

		int[] ints = StringUtils.toCodePoints(SystemUtils.getHostName());
		int sums = 0;
		for (int i: ints) {
			sums += i;
		}
		return (long)(sums % 32);
	}


	/**
	 * 静态工具类
	 *
	 * @return
	 */
	public static synchronized Long generateId(){
		//获取到当前id值
		long id = idWorker.nextId();
		return id;
	}

	//==============================Test=============================================
	/** 测试 */
	public static void main(String[] args) {
		System.out.println(System.currentTimeMillis());
		long startTime = System.nanoTime();
		for (int i = 0; i < 50; i++) {
			long id = SnowflakeIdWorker.generateId();
			System.out.println(id);
		}
		System.out.println((System.nanoTime()-startTime)/1000000+"ms");
	}
}

解决方案3

使用hutool工具

添加依赖

<dependency>
    <groupId>cn.hutool</groupId>
    <artifactId>hutool-all</artifactId>
    <version>5.1.0</version>
</dependency>

创建一个service层，创建一个接口，和一个实体类，用来完成雪花算法的实现调用

 

IdGeneratorSnowflake类

@Slf4j
@Component
public class IdGeneratorSnowflake {

    //定义机房的位置 范围是  0~31
    private long workerId=0;
    //定义机房的机器编号 范围是 0~31
    private long datacneterId=1;
    private Snowflake snowflake= IdUtil.createSnowflake(workerId,datacneterId);

    //使用这个注解完成加载初始化的工作
    @PostConstruct
    public void init(){

        //获取当前机器的workId
        try {
            workerId= NetUtil.ipv4ToLong(NetUtil.getLocalhostStr());
            log.info("当前机器的workId是:{}",workerId);
        } catch (Exception e) {
            e.printStackTrace();
            log.info("当前机器的workId获取失败",e);
            workerId=NetUtil.getLocalhostStr().hashCode();
        }

    }


    public synchronized long snowflakeId( ) {
        return snowflake.nextId();
    }

    public synchronized long snowflakeId(long workerId,long datacneterId) {
        Snowflake snowflake=IdUtil.createSnowflake(workerId,datacneterId);
        return snowflake.nextId();
    }


    public static void main(String[] args) {
        IdGeneratorSnowflake idGenerator = new IdGeneratorSnowflake();
        System.out.println(idGenerator.snowflakeId());
    }

}

SnowFlakeService类

@Component
public class SnowFlakeService {


    //依赖注入实现获得值得类
    @Resource
    private IdGeneratorSnowflake idGeneratorSnowflake;
    
    public String getIDBySnowflake(){
        ExecutorService executorService=null;
        try {
            //创建一个线程池
            executorService =Executors.newFixedThreadPool(5);
            //设置线程池的任务
            for (int i=0;i<20;i++){
                executorService.submit(()->{
                    //这个20个线程都要获得雪花算法的值
                    System.out.println(idGeneratorSnowflake.snowflakeId());
                });
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            //关闭线程池
            executorService.shutdown();
        }
        return "hello sonwflake";
    }
}

创建一个controller包

@RestController
public class SnowflakeController {

    @Resource
    private SnowFlakeService service;

    @GetMapping("/snowflake")
    public String getSnowflake(){
        return service.getIDBySnowflake();
    }
}

创建主启动类


@RestController
public class SnowflakeController {

    @Resource
    private SnowFlakeService service;

    @GetMapping("/snowflake")
    public String getSnowflake(){
        return service.getIDBySnowflake();
    }
}

 

\\追光者//
关注
  • 0
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
KochsAlgorithm:基于Koch算法的雪花建模程序
07-09
**Koch雪花算法详解** ...Koch雪花算法不仅是一个有趣的数学概念，也是学习递归、分形和图形编程的好案例。通过实现这个算法，开发者可以提升自己的编程技巧，同时领略到数学之美和计算机科学的神奇魅力。
推特雪花算法工具类
01-21
分布式自增长ID，支持分布式生成唯一主键，适合mysql分片部署时，生成唯一主键的场景
mybatis-plus 主键自增问题
weixin_46528266的博客
03-20 7676
mybatis-plus 主键自增问题
雪花算法的使用
Lantzruk的博客
11-20 294
雪花算法（Snowflake Algorithm）是一种用于生成唯一ID的分布式算法。它最初是由Twitter开发的，用于生成分布式系统中的唯一标识符。雪花算法的核心思想是将一个64位的整数ID分成多个部分，每个部分表示不同的信息。总体来说，雪花算法是一种简单且高效的分布式ID生成方案，但在特定场景下需要注意其一些缺点。雪花算法的使用(工具类utils)
雪花算法的使用与说明
最新发布
weixin_62432037的博客
04-16 418
后台生成SessionId需要保证全局唯一，我们可借鉴SnowFlake（雪花算法）来实现；什么是雪花算法？雪花算法是Twitter公司内部为分布式环境下生成唯一ID的一种算法解决方案，底层会帮助我们生成一个64位(比特位)的long类型的Id；不适用：1bit，最高位是符号位，0表示正，1表示负，固定为0时间戳：41bit，毫秒级的时间戳(41位长度可以使用69年)标识位：5bit数据中心ID，5bit工作机器ID，两个标识位组合起来最多可以支持部署1024个节点。
介绍雪花算法，并学习怎么使用雪花算法
LJH_java10086的博客
10-10 216
雪花算法（Snowflake）是一种生成唯一ID的算法，它由Twitter公司开发并开源。它主要的应用场景是在分布式系统中生成唯一ID，以保证数据的一致性和可追溯性。雪花算法的核心思想是将一个64位的整数ID分为5个部分：使用Java语言实现雪花算法可以分为以下步骤： 以上就是使用Java实现雪花算法的详细步骤。需要注意的是，由于使用了时间戳，所以生成的ID的唯一性、有序性和可逆性都得到了保证，但是如果系统时钟发生回拨，则会出现重复ID的风险，因此需要对系统时钟进行监测和调整。
雪花算法详解(1)，2024年最新帮你解决95%以上的问题
2401_84166306的博客
04-08 991
95%以上大数据开发知识点，真正体系化！**
MybatisPlus学习笔记
张氏小毛驴的博客
08-11 1156
官网：https://baomidou.com/pages/24112f/简称为MP，是一个Mybatis的增强工具，在Mybatis的基础上只做增强不做改变，为简化开发，提高效率而生。对比mybatis，MP减少了sql的书写，之前的mybatis是需要将sql语句写在xml文件中，涉及的操作比较繁琐，而MP基本不用书写简单SQL，开发起来比较方便，而且MP拥有的特性也很受用。...
雪花算法rust版本_代码_下载
06-11
在实际应用中，Rust版本的雪花算法可以广泛应用于需要全局唯一标识的场景，例如数据库主键、分布式系统中的消息ID、订单号等。Rust的类型系统和内存安全性也确保了这个库在生产环境中的可靠性和效率。 通过阅读和...
fenxing.rar_fenxing_分形算法_雪花
09-20
"fenxing.rar_fenxing_分形算法_雪花"这个标题暗示了压缩包中包含的资源是关于分形算法的实现，特别是与雪花形态相关的程序或教程。这种算法的应用广泛，不仅在艺术和图形设计中有显著效果，还在自然科学、计算机...
2008年1月高等教育自学考试福建省统一命题考试数据库及其应用试题及答案.docx
02-01
【数据库及其应用试题及答案详解】 本篇内容主要涵盖了2008年1月高等教育自学考试福建省统一命题的“数据库及其应用”课程的试题及答案，旨在帮助考生深入理解和掌握数据库系统的基础理论、设计方法以及实际操作...
SnowFlying.rar_雪花
09-23
这是一个很好的学习案例，展示了如何在Visual C++ 6.0环境下开发交互式的2D图形应用。 【描述】中提到的功能点解析如下： 1. **雪花数量**：程序能够控制屏幕上同时存在的雪花粒子数量，这涉及到粒子系统的设计，...
屏幕飘散雪花的应用程序
01-01
屏幕飘散雪花的应用程序
小白文 理解SnowFlake(雪花算法)
Doub1's Blog
05-25 2102
小白文 理解SnowFlake（雪花算法）组成结构解决了什么问题各个BIT位作用小白文理解雪花算法单线程下的简单栗子 雪花算法（SnowFlake）由Twitter创造的，是一个唯一ID生成算法，且具备有序性和可扩展性. 雪花算法难吗？其实并不难，甚至说简单。思路远比技术和代码重要得多。 组成结构 生成出的ID是一个64bit的整数，其中时间戳占41位，数据中心ID占5位，机器ID占5位，自增序列占12位，还有1位是符号位。 这个符号位可以是无符号，这样就可以扩大使用时间或其他地方的bit位数，但是为什么在
@Component注入与@Bean注入的区别
喜欢藏风里
03-30 1276
package cn.ithers.cloudalbum.utils; public class IdWorker { /** * 开始时间截 */ private final long twepoch = 1420041600000L; /** * 机器id所占的位数 */ private final long workerIdBits = 5L; /** * 数据标识id所占的位数 */
雪花算法简介以及代码实现
D1842501760的博客
04-04 4094
雪花算法学习笔记
雪花算法的原理和实现Java
热门推荐
雨夜青草的博客
05-05 22万+
SnowFlake 算法，是 Twitter 开源的分布式 id 生成算法。其核心思想就是：使用一个 64 bit 的 long 型的数字作为全局唯一 id。在分布式系统中的应用十分广泛，且ID 引入了时间戳，基本上保持自增的。 这 64 个 bit 中，其中 1 个 bit 是不用的，然后用其中的 41 bit 作为毫秒数，用 10 bit 作为工作机器 id，12 bit 作为序列号。...
雪花算法
凉茶微凉
01-30 964
雪花算法： 雪花算法的原始版本是scala版，用于生成分布式ID（纯数字，时间顺序）,订单编号等。 自增ID：对于数据敏感场景不宜使用，且不适合于分布式场景。 GUID：采用无意义字符串，数据量增大时造成访问过慢，且不宜排序。 算法描述： • 最高位是符号位，始终为0，不可用。 • 41位的时间序列，精确到毫秒级，41位的长度可以使用69年。时间位还有一个很重要的作用是可以根据时间进行排序。 • ...
雪花算法(snowflake) ：分布式环境，生成全局唯一的订单号 ｜ CSDN 博文精选
CSDN云计算
11-01 2336
戳蓝字“CSDN云计算”关注我们哦！作者 |琦彦责编 | 阿秃转自 ｜ CSDN 博客snowflake方案snowflake是Twitter开源的分布式ID生成算法，结果是一个long型的ID。这种方案大致来说是一种以划分命名空间（UUID也算，由于比较常见，所以单独分析）来生成ID的一种算法，这种方案把64-bit分别划分成多段，分开来标示机器、时间等。其核心思想是：使用41bit作为毫...
springboot使用雪花算法
08-16
在Spring Boot中使用雪花算法生成唯一ID，你可以按照以下步骤进行： 1. 添加依赖：首先，在你的Spring Boot项目的pom.xml文件中添加snowflake算法的依赖配置。可以使用snowflake-id-generator库，如前面所示的依赖配置。 2. 创建雪花算法ID生成器：在你的项目中创建一个雪花算法ID生成器的类，可以命名为SnowflakeIdGenerator或者其他你喜欢的名称。你可以使用snowflake-id-generator库提供的SnowflakeIdGenerator类，也可以自己实现一个ID生成器。 3. 配置参数：在生成器类中，你需要配置雪花算法所需的参数，包括工作机器ID。可以通过配置文件或者代码来设置这些参数。 4. 生成唯一ID：在需要生成唯一ID的地方，调用雪花算法ID生成器的方法来生成ID。例如，可以通过调用generateId()方法来获取一个唯一ID。 下面是一个简单的示例代码： ```java @Component public class SnowflakeIdGenerator { private final SnowflakeIdWorker idWorker; public SnowflakeIdGenerator(@Value("${snowflake.workerId}") long workerId) { this.idWorker = new SnowflakeIdWorker(workerId); } public long generateId() { return idWorker.nextId(); } } ``` 在上面的示例中，我们使用了SnowflakeIdWorker类来实现雪花算法的ID生成器。通过构造函数传入工作机器ID，然后调用nextId()方法来生成唯一ID。 注意：你还需要在配置文件中配置snowflake.workerId参数，用于设置工作机器ID。 这样，你就可以在Spring Boot项目中使用雪花算法生成唯一ID了。通过注入SnowflakeIdGenerator类，调用generateId()方法即可获取唯一ID。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值