精华内容
下载资源
问答
  • 2021-11-18 16:54:40

    https://www.jb51.net/article/194168.htm

    更多相关内容
  • 雪花算法ID生成器 一个适合大量数据的主键生成器 可以尽可能的让数据靠拢; 可以赋予主键更多的区分信息 支持数据库的扩容/分片
  • SnowflakeId雪花ID生成

    2022-04-06 23:17:27
    Java雪花ID生成
    
    /**
     * 雪花Id生成器
     *
     * @author zhuyu
     * @date 2022/4/6 10:32 下午
     */
    public class SnowflakeIdGenerator {
    
        /**
         * 单例
         */
        public static SnowflakeIdGenerator instance = new SnowflakeIdGenerator();
    
        /**
         * 初始化单例
         * @Param workerId 最大值8192
         */
        public synchronized void init(long workerId) {
            if (workerId > MAX_WORKER_ID) {
                //ZK分配的workerId过大
                throw new IllegalArgumentException("woker Id wrong: " + workerId);
            }
            instance.workerId = workerId;
        }
    
        private SnowflakeIdGenerator() {
        }
    
        public static void main(String[] args) {
            //new SnowflakeIdTest().snowflakeIdTest();
    
            //初始化id生成器
            SnowflakeIdGenerator.instance.init(1);
            System.out.println(" ID001:" + SnowflakeIdGenerator.instance.nextId());
            System.out.println(" ID001:" + SnowflakeIdGenerator.instance.nextId());
    
            SnowflakeIdGenerator.instance.init(100);
            System.out.println(" ID100:" + SnowflakeIdGenerator.instance.nextId());
            System.out.println(" ID100:" + SnowflakeIdGenerator.instance.nextId());
    
            SnowflakeIdGenerator.instance.init(300);
            System.out.println(" ID300:" + SnowflakeIdGenerator.instance.nextId());
            System.out.println(" ID300:" + SnowflakeIdGenerator.instance.nextId());
    
            SnowflakeIdGenerator.instance.init(2145);
            System.out.println(" ID2145:" + SnowflakeIdGenerator.instance.nextId());
            System.out.println(" ID2145:" + SnowflakeIdGenerator.instance.nextId());
    
            SnowflakeIdGenerator.instance.init(7634);
            System.out.println(" ID7634:" + SnowflakeIdGenerator.instance.nextId());
            System.out.println(" ID7634:" + SnowflakeIdGenerator.instance.nextId());
            System.out.println(" ID7634 length:" + String.valueOf(SnowflakeIdGenerator.instance.nextId()).length());	
        }
    
        /**
         * 开始使用该算法的时间为2017-01-01 00:00:00
         */
        private static final long START_TIME = 1483200000000L;
    
        /**
         * worker id 的位数,最多支持8192个节点
         */
        private static final int WORKER_ID_BITS = 13;
    
        /**
         * 序列号,支持单节点最高每毫秒的最大ID数1024
         */
        private final static int SEQUENCE_BITS = 10;
    
        /**
         * 最大的 worker id,8091
         * -1 的补码(二进制全1)右移13位,然后取反
         */
        private final static long MAX_WORKER_ID = ~(-1L << WORKER_ID_BITS);
    
        /**
         * 最大的序列号,1023
         * -1 的补码(二进制全1)右移10位, 然后取反
         */
        private final static long MAX_SEQUENCE = ~(-1L << SEQUENCE_BITS);
    
        /**
         * worker 节点编号的移位
         */
        private final static long APP_HOST_ID_SHIFT = SEQUENCE_BITS;
    
        /**
         * 时间戳的移位
         */
        private final static long TIMESTAMP_LEFT_SHIFT = WORKER_ID_BITS + APP_HOST_ID_SHIFT;
    
        /**
         * 该项目的worker 节点 id
         */
        private long workerId;
    
        /**
         * 上次生成ID的时间戳
         */
        private long lastTimestamp = -1L;
    
        /**
         * 当前毫秒生成的序列
         */
        private long sequence = 0L;
    
        /**
         * Next id long.
         *
         * @return the nextId
         */
        public Long nextId() {
            return generateId();
        }
    
        /**
         * 生成唯一ID的具体实现
         */
        private synchronized long generateId() {
            long current = System.currentTimeMillis();
    
            if (current < lastTimestamp) {
                //如果当前时间小于上一次ID生成的时间戳
                //说明系统时钟回退过,出现问题返回-1,生成ID失败
                return -1;
            }
    
            if (current == lastTimestamp) {
                //如果当前生成ID的时间还是上次的时间,那么对sequence序列号进行+1
                sequence = (sequence + 1) & MAX_SEQUENCE;
                if (sequence == MAX_SEQUENCE) {
                    //当前毫秒生成的序列数已经大于最大值
                    //那么阻塞到下一毫秒再获取新的时间戳
                    current = this.nextMs(lastTimestamp);
                }
            } else {
                //当前的时间戳已经是下一毫秒
                sequence = 0L;
            }
    
            //更新上次生成ID的时间戳
            lastTimestamp = current;
    
            //进行移位操作生成int64的唯一ID
            //时间戳右移23位
            long time = (current - START_TIME) << TIMESTAMP_LEFT_SHIFT;
    
            //workerId 右移10位
            long workerId = this.workerId << APP_HOST_ID_SHIFT;
    
            return time | workerId | sequence; //返回ID
        }
    
        /**
         * 阻塞到下一毫秒
         */
        private long nextMs(long timeStamp) {
            long current = System.currentTimeMillis();
            while (current <= timeStamp) {
                current = System.currentTimeMillis();
            }
            return current;
        }
    
    }	
    
    展开全文
  • 索引此时就引入了雪花ID,它既能保证ID的有序性,又保证了ID的唯一性,兼顾自增ID和UUID的共同优点。 雪花ID的优点: 高性能高可用:生成时不依赖于数据库,完全在内存中生成。 容量大:每秒能生成数百万的自增ID。...
  • mysql雪花算法生成唯一整型ID主键的实现方法,整型ID作为主键好处有很多,比如节省存储空间、插入和查询排序快、具有一定规律性(时间顺序)等。
  • 主要介绍了Js Snowflake(雪花算法)生成随机ID的实现方法,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友们下面随着小编来一起学习学习吧
  • 雪花ID生成

    2021-09-08 15:54:28
    /** * @Author Chenxinlele * @Date 2021/8/11 15:58 * @Version 1.0 */ public class SnowflakeId { /** * id自增器(雪花算法) * * @author renjie * @version 1.0.0 */ private final static long twepoch = ...

    首先写一个util工具类

    package com.xuehua.util;
    
    import java.lang.management.ManagementFactory;
    import java.lang.management.RuntimeMXBean;
    import java.net.NetworkInterface;
    import java.net.SocketException;
    import java.util.Enumeration;
    
    /**
     * @Author Chenxinlele
     * @Date 2021/8/11 15:58
     * @Version 1.0
     */
    public class SnowflakeId {
    
        /**
         * id自增器(雪花算法)
         *
         * @author renjie
         * @version 1.0.0
         */
        private final static long twepoch = 12888349746579L;
        // 机器标识位数
        private final static long workerIdBits = 5L;
        // 数据中心标识位数
        private final static long datacenterIdBits = 5L;
    
        // 毫秒内自增位数
        private final static long sequenceBits = 12L;
        // 机器ID偏左移12位
        private final static long workerIdShift = sequenceBits;
        // 数据中心ID左移17位
        private final static long datacenterIdShift = sequenceBits + workerIdBits;
        // 时间毫秒左移22位
        private final static long timestampLeftShift = sequenceBits + workerIdBits + datacenterIdBits;
        //sequence掩码,确保sequnce不会超出上限
        private final static long sequenceMask = -1L ^ (-1L << sequenceBits);
        //上次时间戳
        private static long lastTimestamp = -1L;
        //序列
        private long sequence = 0L;
        //服务器ID
        private long workerId = 1L;
        private static long workerMask = -1L ^ (-1L << workerIdBits);
        //进程编码
        private long processId = 1L;
        private static long processMask = -1L ^ (-1L << datacenterIdBits);
    
        private static SnowflakeId snowFlake = null;
    
        static {
            snowFlake = new SnowflakeId();
        }
    
        public static synchronized long nextId() {
            return snowFlake.getNextId();
        }
    
        private SnowflakeId() {
    
            //获取机器编码
            this.workerId = this.getMachineNum();
            //获取进程编码
            RuntimeMXBean runtimeMXBean = ManagementFactory.getRuntimeMXBean();
            this.processId = Long.valueOf(runtimeMXBean.getName().split("@")[0]).longValue();
    
            //避免编码超出最大值
            this.workerId = workerId & workerMask;
            this.processId = processId & processMask;
        }
    
        public synchronized long getNextId() {
            //获取时间戳
            long timestamp = timeGen();
            //如果时间戳小于上次时间戳则报错
            if (timestamp < lastTimestamp) {
                try {
                    throw new Exception("Clock moved backwards.  Refusing to generate id for " + (lastTimestamp - timestamp) + " milliseconds");
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
            //如果时间戳与上次时间戳相同
            if (lastTimestamp == timestamp) {
                // 当前毫秒内,则+1,与sequenceMask确保sequence不会超出上限
                sequence = (sequence + 1) & sequenceMask;
                if (sequence == 0) {
                    // 当前毫秒内计数满了,则等待下一秒
                    timestamp = tilNextMillis(lastTimestamp);
                }
            } else {
                sequence = 0;
            }
            lastTimestamp = timestamp;
            // ID偏移组合生成最终的ID,并返回ID
            long nextId = ((timestamp - twepoch) << timestampLeftShift) | (processId << datacenterIdShift) | (workerId << workerIdShift) | sequence;
            return nextId;
        }
    
        /**
         * 再次获取时间戳直到获取的时间戳与现有的不同
         *
         * @param lastTimestamp
         * @return 下一个时间戳
         */
        private long tilNextMillis(final long lastTimestamp) {
            long timestamp = this.timeGen();
            while (timestamp <= lastTimestamp) {
                timestamp = this.timeGen();
            }
            return timestamp;
        }
    
        private long timeGen() {
            return System.currentTimeMillis();
        }
    
        /**
         * 获取机器编码
         *
         * @return
         */
        private long getMachineNum() {
            long machinePiece;
            StringBuilder sb = new StringBuilder();
            Enumeration<NetworkInterface> e = null;
            try {
                e = NetworkInterface.getNetworkInterfaces();
            } catch (SocketException e1) {
                e1.printStackTrace();
            }
            while (e.hasMoreElements()) {
                NetworkInterface ni = e.nextElement();
                sb.append(ni.toString());
            }
            machinePiece = sb.toString().hashCode();
            return machinePiece;
        }
    }
    

    直接调用

    long xhId =SnowflakeId.nextId();

    展开全文
  • 雪花ID生成工具

    千次阅读 2020-11-12 11:19:25
    public class SmallSnowflake { public static final int NODE_SHIFT = 10; public static final int SEQ_SHIFT = 12; public static final short MAX_NODE = 1023; public static final short MAX_SEQUENCE =...
    public class SmallSnowflake {
    
        public static final int NODE_SHIFT = 10;
        public static final int SEQ_SHIFT  = 12;
    
        public static final short MAX_NODE     = 1023;
        public static final short MAX_SEQUENCE = 4095;
    
        private short sequence;
        private long  referenceTime;
    
        private int node;
    
       
        public SmallSnowflake(int node) {
            if (node < 0 || node > MAX_NODE) {
                throw new IllegalArgumentException(String.format("node must be between %s and %s", 0, MAX_NODE));
            }
            this.node = node;
        }
    
        
        public synchronized long next() {
            long currentTime = this.getCurrentTimeMillis();
            long counter;
            if (currentTime < referenceTime) {
                throw new RuntimeException(String.format("Last referenceTime %s is after reference time %s", referenceTime, currentTime));
            } else if (currentTime > referenceTime) {
                this.sequence = 0;
            } else {
                if (this.sequence < SmallSnowflake.MAX_SEQUENCE) {
                    this.sequence++;
                } else {
                    throw new RuntimeException("Sequence exhausted at " + this.sequence);
                }
            }
            counter = this.sequence;
            referenceTime = currentTime;
    
            return currentTime << NODE_SHIFT << SEQ_SHIFT | node << SEQ_SHIFT | counter;
        }
    
        protected long getCurrentTimeMillis() {
            return System.currentTimeMillis() / 1000;
        }
    
    
    public class LargeSnowflake extends SmallSnowflake {
    
        public LargeSnowflake(int node) {
            super(node);
        }
    
        @Override
        protected long getCurrentTimeMillis() {
            return System.currentTimeMillis();
        }
    }
    
    
       public static void main(String[] args) {
            LargeSnowflake lsf = new LargeSnowflake(1);
            System.out.println(lsf.next());
            SmallSnowflake ssf = new SmallSnowflake(1);
            System.out.println(ssf.next());
        }

     

    展开全文
  • 引用不知道谁说得名言:世界上没有两片完全相同的雪花,但是会有相同的ID 分布式系统中会将一个业务的系统部署到多台服务器上,用户随机访问其中一台,而之所以引入分布式系统就是为了让整个系统能够承载更大的...
  • Mysql全局ID生成方法

    2021-01-21 14:55:19
    既然要sharding,那么不可避免的要讨论到sharding key问题,在有些业务系统中,必须保证sharding key全局唯一,比如存放商品的数据库等,那么如何生成全局唯一的ID呢,下文将从DBA的角度介绍几种常见的方案。...
  • 雪花算法:分布式唯一ID生成利器

    千次阅读 2022-02-23 09:12:59
    无论是在分布式系统中的ID生成,还是在业务系统中请求流水号这一类唯一编号的生成,都是软件开发人员经常会面临的一场景。而雪花算法便是这些场景的一个解决方案。 以分布式ID为例,它的生成往往会在唯一性、递增性...
  • 雪花生成Id

    2018-05-05 15:20:27
    雪花是一个可以生成不重复的,唯一的ID,可以用于app的id生成和数据库的主键生成
  • 雪花算法生成id

    2020-12-29 10:25:45
    packagecom.shopping.test;/*** SnowFlake的结构如下(每部分用-分开):* 0 - 0000000000 0000000000 0000000000 0000000000 0 - 00000 - 00000 - 000000000000 * 1位标识,由于long...所以id一般是正数,最高位是0*...
  • //下面两个每个5位,加起来就是10位的工作机器id private long workerId; //工作id private long datacenterId; //数据id //12位的序列号 private long sequence; public SnowflakeIdWorker(long workerId, ...
  • 雪花算法id生成

    2022-06-10 16:09:22
    雪花算法生成id
  • 生成一个随机的 ID 有很多种做法,比如说 GUID 和 UUID。但如果想要有序,可以插入数据库中做数字主键,那就有了雪花算法。雪花算法得到的是个比较大的数字,比较大,而 JS 中 Number 类型的最大值 Number.MAX_SAFE_...
  • 基于snowflake算法实现的id生成器 这是go版本,java版本可查看 使用 go get github.com/sumory/idgen 使用前请先了解snowflake算法,并知晓其注意事项. 基本使用 每个由idgen生成的id都是int64的正整数,且每个id都...
  • 雪花算法生成唯一ID

    2020-12-20 05:35:29
    能够在分布式场景中为我们在每毫秒里面生成4096个纯数字的有序的唯一id,但只能连续使用69年(代码在69年后就不能保证生成的是唯一id了),并且你的分布式机器小于1024台。当然这里面出现的4096,69,1024都是可以通过...
  • JAVA-雪花算法ID生成

    2022-06-07 14:03:00
    雪花算法ID生成
  • ID生成 雪花算法

    2021-01-15 08:21:18
    Twitter的分布式雪花算法 SnowFlake 每秒自增生成26个万个可排序的ID1、twitter的SnowFlake生成ID能够按照时间有序生成2、SnowFlake算法生成id的结果是一个64bit大小的整数3、分布式系统内不会产生重复id(用有...
  • GUID,最大唯一标识符,是一种有算法生成的二进制长度为128位的数字标识符,在理想情况下,任何计算机和计算机生成都不会生成两个相同的GUID,所以可以保证唯一性。但也是有优缺点的。分别如下: 优点如下: 分布式...
  • java 雪花算法生成ID

    万次阅读 2020-04-21 09:22:51
    一般情况,实现全局唯一ID,有三种方案,分别是通过中间件方式、UUID、雪花算法。  方案一,通过中间件方式,可以是把数据库或者redis缓存作为媒介,从中间件获取ID。这种呢,优点是可以体现全局的递增趋势(优点...
  • 迄今为止最全面的分布式主键ID生成器。 优化的雪花算法(SnowFlake)——雪花漂移算法,在缩短ID长度的同时,具备极高瞬时并发处理能力(50W/0.1s)。 原生支持 C#/Java/Go/Rust/C/SQL 等多语言,且提供 PHP 扩展及 ...
  • ID生成-雪花算法

    2021-11-15 20:10:28
    雪花算法就是针对这64位进行设计。 第1位二进制值固定位0,没有业务含义。 第2~42位,共41位二进制,为时间戳,用于存入精确到毫秒数的时间。 第43~52位,共10位二进制,为工作机器id位。 第53~64位,共12位二...
  • python版雪花算法生成唯一ID

    千次阅读 热门讨论 2020-08-26 11:55:01
    一、雪花算法图解 下方为源码,返回的结果为19位,为10进制表示,使用二进制表示就是64位,所以不必...2、唯一id生成块 文件名:xuehuaid.py # Twitter's Snowflake algorithm implementation which is used to gene
  • 文章目录前言UUID雪花ID雪花ID生成类测试自动递增重新计数测试自增Id的好处自增Id的坏处总结 前言 那些个公众号天天推来推去就几篇剩饭文章,直接实操测试一下。 单元测试:SpringBootTest /* * 使用STS创建的...
  • 通过@GenericGenerator...这里使用hutool工具包里封装好的雪花算法生成id直接,需引入hutool-all依赖。 <dependency> <groupId>cn.hutool</groupId> <artifactId>hutool-all</artifactI.
  • 雪花算法工具类 package com.anft.utils; import org.apache.commons.lang3.RandomUtils; import java.util.Date; /** * SnowFlake的结构如下(每部分用-分开):<br> * 0 - 0000000000 0000000000 ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 10,508
精华内容 4,203
关键字:

雪花id如何生成