ID Generator

最新推荐文章于 2024-08-09 07:54:34 发布
最新推荐文章于 2024-08-09 07:54:34 发布
阅读量263 收藏
点赞数
分类专栏： SE 文章标签： java

    关于ID Generator，想必大多数项目都有应用。跟按需生成ID相比，预生成一定数量的ID并加以缓存的方式更有助于提升性能。预生成ID的时机，通常是在发现缓存的ID用尽的时候。这种方式有个缺陷，即从调用者的角度来看每次取得ID所花费的时间可能并不均等。

    如果应用要求每次取得ID时都要尽可能的快且时间均等，那么ID Generator可以在发现缓存的ID用尽之前进行预生成，保持缓存中总是有可用的ID（例如每次预生成100个ID，在缓存中只剩下20个ID的时机再次进行预生成）。这种做法面临的主要问题就是并发控制。以及预生成时如果抛出异常， 那么该异常如何传播给请求ID的调用者（在预生成的时候，可能并没有没有线程在请求ID）。

    以下是一段笔者在项目中采用的代码片段, 首先是IdGenerator接口，以及几个跟ID生成相关的异常:

public interface IdGenerator<T> {
    T nextId();
}

public class GenerationException extends NestableRuntimeException {
    ...
}

public class GenerationInterruptedException extends GenerationException {
    ...
}

public class GenerationTimeoutException extends GenerationException {
    ...
}

 

    接下来是跟ID预生成相关的接口IdLoader

public interface IdLoader<T> {
    List<T> load() throws Exception;
}

 

    CachedIdGenerator是IdGenerator的一个实现，用于对ID缓存的管理，以及在适当的时机调用IdLoader进行ID的预生成。其最重要的一个属性是preLoadThreshold，通过调整这个属性的值，便可以控制ID预生成的时机：

  • 负值：在发现缓存中的已经没有可用的ID进行分配时生成。生成ID的过程中，调用nextId()方法的线程会被阻塞。
  • 0：在分配了缓存中的最后一个ID时生成，由于此时缓存中有最后一个可用的ID，因此调用nextId()方法的线程不会被阻塞。
  • 正值：在缓存中的ID个数小于还有该阀值时生成，调用nextId()方法的线程不会被阻塞。

    关于CachedIdGenerator的并发控制：

  • 如果多个线程同时调用nextId()方法，那么通过排他锁进行控制。
  • CachedIdGenerator内部使用一个单独的线程（以下成load线程）进行ID预生成（即调用IdLoader的load()方法的线程）。
  • 如果某次对nextId()方法的调用触发了ID预生成，那么在ID预生成结束之前该线程一直被阻塞。如果此时还有其它线程调用nextId()方法，那么这些线程也会被阻塞，即不会同时重复触发ID预生成。
  • 如果IdLoader的load()方法抛出异常，那么CachedIdGenerator对该异常的处理区分以下两个场景：1 如果此时有调用nextId()方法的线程被阻塞，那么该异常会被传播给调用nextId()方法的线程；2 如果此时没有调用nextId()方法的线程被阻塞，那么CachedIdGenerator会将该异常记录到日志中，同时将 preLoadThreshold 自动调整为-1。在最终缓存的中的ID用尽时，才会再次触发ID预生成，此时调用nextId()方法的线程一定被阻塞，如果IdLoader的load 方法再次抛出异常，那么这个异常会被传播给调用nextId()方法的线程。
import java.util.LinkedList;
import java.util.List;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;
import java.util.concurrent.atomic.AtomicBoolean;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.concurrent.atomic.AtomicReference;
import java.util.concurrent.locks.ReentrantLock;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

public class CachedIdGenerator<T> implements IdGenerator<T> {
    //
    private static final Logger LOGGER = LoggerFactory.getLogger(CachedIdGenerator.class);
    
    //
    private final AsyncIdLoader loader;
    private final ReentrantLock lock = new ReentrantLock();
    private final LinkedList<T> cache = new LinkedList<T>();
    private final AtomicBoolean verbose = new AtomicBoolean(false);
    private final AtomicInteger preLoadThreshold = new AtomicInteger(0);
    
    /**
     * 
     */
    public CachedIdGenerator(IdLoader<T> loader) {
        this(loader, 0);
    }
    
    public CachedIdGenerator(IdLoader<T> loader, int preLoadThreshold) {
        this.loader = new AsyncIdLoader(loader);
        this.preLoadThreshold.set(preLoadThreshold);
    }
    
    /**
     * 
     */
    public final T nextId() {
        try {
            while(true) {
                final Future<T> f = next();
                final T r = f.get();
                if(r != null) {
                    return r;
                }
            }
        } catch (InterruptedException e) {
            throw new GenerationInterruptedException(e);
        } catch(ExecutionException e) {
            throw new GenerationException(((ExecutionException)e).getCause());
        } catch(Exception e) {
            throw new GenerationException(e);
        }
    }
    
    public final T nextId(long timeout, TimeUnit unit) {
        try {
            while(true) {
                //
                final long now = System.nanoTime();
                final Future<T> f = next();
                final T r = f.get(timeout, unit);
                if(r != null) {
                    return r;
                }
                
                //
                timeout -= unit.convert(System.nanoTime() - now, TimeUnit.NANOSECONDS);
                if(timeout < 0) {
                    throw new TimeoutException();
                }
            }
        } catch(TimeoutException e) {
            throw new GenerationTimeoutException(e);
        } catch (InterruptedException e) {
            throw new GenerationInterruptedException(e);
        } catch(ExecutionException e) {
            throw new GenerationException(((ExecutionException)e).getCause());
        } catch(Exception e) {
            throw new GenerationException(e);
        }
    }

    public boolean isVerbose() {
        return verbose.get();
    }
    
    public void setVerbose(boolean verbose) {
        this.verbose.set(verbose);
    }

    public void disablePreLoad() {
        this.preLoadThreshold.set(-1);
    }
    
    public int getPreLoadThreshold() {
        return preLoadThreshold.get();
    }
    
    public void setPreLoadThreshold(int threshold) {
        this.preLoadThreshold.set(threshold);
    }
    
    /**
     * 
     */
    protected Future<T> next() {
        Future<T> r = null;
        this.lock.lock();
        try {
            //
            if(!this.cache.isEmpty()) {
                final DummyFuture<T> df = new DummyFuture<T>();
                df.setResult(this.cache.removeFirst());
                r = df;
            }
            
            //
            if(r == null) {
                r = this.loader.load();
            } else if(cache.size() <= this.preLoadThreshold.get()) {
                this.loader.load();
            }
        } finally {
            this.lock.unlock();
        }
        return r;
    }
    
    /**
     * 
     */
    protected class AsyncIdLoader {
        //
        private final IdLoader<T> loader;
        private final ExecutorService executor;
        private final AtomicReference<Future<T>> result = new AtomicReference<Future<T>>();
        
        /**
         * 
         */
        public AsyncIdLoader(IdLoader<T> loader) {
            this.loader = loader;
            this.executor = Executors.newFixedThreadPool(1, new XThreadFactory(getClass().getSimpleName(), true));
        }
        
        /**
         * 
         */
        public Future<T> load() {
            //
            final Future<T> current = this.result.get();
            if(current != null) { // Loading is in progress
                return current;
            }
            
            //
            final Future<T> r = this.executor.submit(new Callable<T>() {

                public T call() throws Exception {
                    List<T> ids = null;
                    try {
                        //
                        if(isVerbose() && LOGGER.isInfoEnabled()) {
                            LOGGER.info("start to load ids, loader: {}", loader);
                        }
                        
                        //
                        ids = loader.load();
                        
                        //
                        if(isVerbose() && LOGGER.isInfoEnabled()) {
                            LOGGER.info("ids were successfully loaded, count: {}, loader: {}", (ids == null ? 0 : ids.size()), loader);
                        }
                        return null;
                    } catch (Exception e) {
                        disablePreLoad();
                        LOGGER.warn("unhandled exception in id loader: " + loader + ", pre-loading was disabled", e);
                        throw e;
                    } finally {
                        //
                        lock.lock();
                        try {
                            result.set(null);
                            if(ids != null && ids.size() > 0) {
                                cache.addAll(ids);
                            }
                        } finally {
                            lock.unlock();
                        }
                    }
                }
            });
            
            //
            this.result.set(r);
            return r;
        }
    } 
}

    最后是CachedIdGenerator用到的几个工具类：

 

public class XThreadFactory implements ThreadFactory {
    //
    private static final Logger LOGGER = LoggerFactory.getLogger(XThreadFactory.class);
    
    //
    private String name;
    private boolean daemon;
    private UncaughtExceptionHandler uncaughtExceptionHandler;
    private final ConcurrentHashMap<String, AtomicLong> sequences;
    
    
    /**
     * 
     */
    public XThreadFactory() {
        this(null, false, null);
    }
    
    public XThreadFactory(String name) {
        this(name, false, null);
    }
    
    public XThreadFactory(String name, boolean daemon) {
        this(name, daemon, null);
    }
    
    public XThreadFactory(String name, boolean daemon, UncaughtExceptionHandler handler) {
        this.name = name;
        this.daemon = daemon;
        this.uncaughtExceptionHandler = handler;
        this.sequences = new ConcurrentHashMap<String, AtomicLong>();
    }

    /**
     * 
     */
    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
    
    public boolean isDaemon() {
        return daemon;
    }
    
    public void setDaemon(boolean daemon) {
        this.daemon = daemon;
    }

    public UncaughtExceptionHandler getUncaughtExceptionHandler() {
        return uncaughtExceptionHandler;
    }
    
    public void setUncaughtExceptionHandler(UncaughtExceptionHandler handler) {
        this.uncaughtExceptionHandler = handler;
    }
    
    /**
     * 
     */
    public Thread newThread(Runnable r) {
        //
        Thread t = new Thread(r);
        t.setDaemon(this.daemon);
        
        //
        String prefix = this.name;
        if(prefix == null || prefix.equals("")) {
            prefix = getInvoker(2);
        }
        t.setName(prefix + "-" + getSequence(prefix));
        
        //
        if(this.uncaughtExceptionHandler != null) {
            t.setUncaughtExceptionHandler(this.uncaughtExceptionHandler);
        } else {
            t.setUncaughtExceptionHandler(new UncaughtExceptionHandler() {
                public void uncaughtException(Thread t, Throwable e) {
                    LOGGER.error("unhandled exception in thread: " + t.getId() + ":" + t.getName(), e);
                }
            });
        }
        
        //
        return t;
    }

    /**
     * 
     */
    private String getInvoker(int depth) {
        Exception e = new Exception();
        StackTraceElement[] stes = e.getStackTrace();
        if(stes.length > depth) {
            return ClassUtils.getShortClassName(stes[depth].getClassName());
        }
        return getClass().getSimpleName();
    }
    
    private long getSequence(String invoker) {
        AtomicLong r = this.sequences.get(invoker);
        if(r == null) {
            r = new AtomicLong(0);
            AtomicLong previous = this.sequences.putIfAbsent(invoker, r);
            if(previous != null) {
                r = previous;
            }
        }
        return r.incrementAndGet();
    }
}

public class DummyFuture<V> implements Future<V> {
    //
    private volatile V result;
    private volatile Throwable throwable;

    /**
     * 
     */
    public boolean isDone() {
        return true;
    }
    
    public boolean isCancelled() {
        return false;
    }
    
    public boolean cancel(boolean mayInterruptIfRunning) {
        return false;
    }

    public V get() throws InterruptedException, ExecutionException {
        if(throwable != null) {
            throw new ExecutionException(throwable);
        } else {
            return result;
        }
    }

    public V get(long timeout, TimeUnit unit) throws InterruptedException, ExecutionException, TimeoutException {
        return get();
    }
    
    /**
     * 
     */
    public void setResult(V result) {
        this.result = result;
    }

    public void setThrowable(Throwable throwable) {
        this.throwable = throwable;
    }
}

public class XFuture<V> implements Future<V> {
    //
    private volatile V result;
    private volatile Object id;
    private volatile Throwable throwable;
    private CountDownLatch done = new CountDownLatch(1);

    /**
     * 
     */
    public XFuture() {
        this(null);
    }
    
    public XFuture(Object id) {
        this.id = id;
    }

    /**
     * 
     */
    public boolean isDone() {
        return done.getCount() != 1;
    }
    
    public boolean isCancelled() {
        return false;
    }
    
    public boolean cancel(boolean mayInterruptIfRunning) {
        return false;
    }

    public V get() throws InterruptedException, ExecutionException {
        //
        done.await();
        
        //
        if(throwable != null) {
            throw new ExecutionException(throwable);
        } else {
            return result;
        }
    }

    public V get(long timeout, TimeUnit unit) throws InterruptedException, ExecutionException, TimeoutException {
        //
        if(!done.await(timeout, unit)) {
            throw new TimeoutException("failed to get in timeout: " + timeout + ", unit: " + unit);
        }
        
        //
        if(throwable != null) {
            throw new ExecutionException(throwable);
        } else {
            return result;
        }
    }
    
    /**
     * 
     */
    public Object getId() {
        return id;
    }
    
    public void setResult(V result) {
        this.result = result;
        this.done.countDown();
    }
    
    public void setThrowable(Throwable throwable) {
        this.throwable = throwable;
        this.done.countDown();
    }
}
iteye_19132
关注
专栏目录
Flowable自定义IdGenerator
Lance
03-26 1725
介绍 Flowable扩展id生成规则 1. maven项目依赖 <dependency> <groupId>org.flowable</groupId> <artifactId>flowable-spring-boot-starter-process</artifactId> <version>6.7.2</version> </dependency> 2. 扩展IdGenerator实现类
idgenerator分布式主键ID生成器
11-11
迄今为止最全面的分布式主键ID生成器。优化的雪花算法（SnowFlake）——雪花漂移算法，在缩短ID长度的同时，具备极高瞬时并发处理能力...支持容器环境自动扩容（自动注册 WorkerId ），单机或分布式唯一IdGenerator。
一个简单的自定义ID 生成器IDGenerator
10-15
一个用Java 编写简单的自定义ID 生成器IDGenerator
Id Generator
qingsongxyz的博客
10-07 1540
Id Generator
IdGenerator - 高性能唯一数字ID生成器
最新发布
gitblog_00994的博客
08-09 597
IdGenerator - 高性能唯一数字ID生成器 IdGenerator????多语言实现，高性能生成唯一数字ID。 ????优化的雪花算法（SnowFlake）——雪花漂移算法，在缩短ID长度的同时，具备极高瞬时并发处理能力（50W/0.1s）。 ????原生支持 C#/Java/Go/Rust/C/JavaScript/TypeScript/Python/Pascal 多语言，提供其它适用于其它语言的多线...
id-generator:整体唯一ID生成器
03-17
id生成器 项目说明 实现请参考 将百度uid-generator组件封装成独立的springboot应用提供服务 使用方法 修改application.properties，配置好数据库 执行doc / init.sql初始化表 运行springboot项目 连接调用 1. 获取单个id: http://localhost:9999/getNextId 2. 批量获取id: http://localhost:9999/getNextIds?num=10 0 < num <= 100 3. 解析id: http://localhost:9999/parseId?id=
Hibernate Id Generator
gyflyx的专栏
03-13 2240
<br />Hibernate Id Generator<br />hibernate的映射文件bean.hbm.xml是跟库表一一对应的,如果库表中存在主键.有时需要自动生成就用native,有时需要在我们insert时就给他赋值用assigned.<br />example:<br />   <id name="id" type="java.lang.String"><br />            <column name="ID" length="20" /><br />            <
idgenerator:idgenerator是基于redis的id生成器
04-06
idgenerator是基于redis的id生成器 dgenerator是基于redis的id生成器 安装 取得 go get github.com/lbfatcgf/idgenerator 快速开始 package main import ( "fmt" "net/http" "os" "os/signal" "syscall" ...
idGenerator：使用golanggo的idGenerator
02-24
#ID产生器 用go实现的id生成器，支持每秒qps：131072，超过需要等待下一秒 依赖 mysql（或zk，redis等） 需要使用mysql来保证多台机器获取到的workId不同当然，如果是单点，那随意设置workId 使用介绍 初始化程序 ...
Java ID Generator-开源
05-04
Jidgen是一个易于使用但功能强大的基于Java的id生成器。 它使用模板来自动生成id和可选的冲突检测，以避免重复的id。
基于百度的UidGenerator改造的全局唯一id生成器
01-22
基于百度的UidGenerator改造的全局唯一id生成器，将原生的基于数据库的改成了基于zookpeer的序列号来替代机器id
随机id生成器
12-15
随机生成数字id，可以用于数据库主键id。ID生成器是指能产生不重复ID服务的程序，在后台开发过程中，尤其是分布式服务、微服务程序开发过程中，经常会用到，例如，为用户的每个请求产生一个唯一ID、为每个消息产生一个ID等等，ID生成器也是进行无状态服务开发的重要需求之一。
全球唯一码生成器（GUID）
03-21
NULL 博文链接：https://zhaoshijie.iteye.com/blog/986297
IdGenerator
Anders 的专栏(Talk is cheap, show me the code！)
11-28 4501
public class IdGenerator { private final static String SELECT_ALL_ID_INFO = "SELECT Name FROM IDGenInfo"; private final static String SELECT_ID_INFO = "SELECT Current, Step FROM IDGenInfo WHERE Name
IdGenerator 唯一Id生成器
m0_53434091的博客
11-22 2134
有些时候我们可能会遇见数据库生成的ID过长，超过了前端 JS Number 类型最大值，须把 Long 型转换为 String 型，如果不转换就会出现报错现象。这个时候我们就可以使用。来生成ID且不会重复。
IdGenerator id主键生成器
鸦教授的博客
08-10 6962
import java.util.concurrent.locks.ReentrantLock; public class IdGenerator { private static final long twepoch = 1404741526058L; private static final long idBits = 5L; private static final...
ID生成器--随机&雪花&redis自增
hefaji的博客
05-07 2400
随着互联网的快速发展，应用的用户量和数据量都在爆炸式增长。在这种情况下，传统的ID生成方法（如数据库的自增主键）已经无法满足需求，因为它们无法在分布式环境中生成唯一的ID。因此，我们需要新的ID生成方法，如随机数+时间戳、雪花算法和Redis自增等，来满足在分布式环境中生成唯一ID的需求。
推荐开源项目：id-generator——高效分布式ID生成器
gitblog_00055的博客
06-22 303
推荐开源项目：id-generator——高效分布式ID生成器 id-generatorid-generator部署即使用的ID生成器, 支持HTTP、Dubbo、Spring Cloud方式.项目地址:https://gitcode.com/gh_mirrors/idg/id-generator 项目介绍 在分布式系统中，如何保证全局ID的唯一性和有序性是开发中的常见问题。id-generat...
SnowflakeIdGenerator 导入依赖
06-10
如果您使用的是Java语言，可以通过以下Maven依赖导入SnowflakeIdGenerator： ```xml <dependency> <groupId>com.github.sharding-sphere</groupId> <artifactId>sharding-core-common</artifactId> <version>5.0.0-alpha</version> </dependency> ``` 如果您使用的是Gradle，可以添加以下依赖： ```groovy implementation 'com.github.sharding-sphere:sharding-core-common:5.0.0-alpha' ``` 请注意，这里的版本号是当前最新的alpha版本，您可以根据自己的需要选择不同的版本号。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值