id本地缓存策略

思路是每次去生成id都要去获取比较慢，可以在启动的时候先获取部分id到缓存中，然后直接在缓存里获取id，当id数量下降到一定程度的时候再去补充id到缓存中

上配置类

package com.felix.spring_cloud_one.config;

import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.stereotype.Component;

@Component
@ConfigurationProperties(
        prefix = "idsetting"
)
public class IdGenerateProperties {

    private IdGenerateProperties.IdentTooker identTooker = new IdGenerateProperties.IdentTooker();

    public void setIdentTooker(IdentTooker identTooker) {
        this.identTooker = identTooker;
    }

    public IdentTooker getIdentTooker() {
        return identTooker;
    }

    public static class IdentTooker {
        private String enable = "false";
        private Integer limitAllowExistNumber = 30;
        private Integer maxKeepNumber = 200;
        private Integer perRequestStep = 100;

        public IdentTooker() {
        }

        public String getEnable() {
            return this.enable;
        }

        public void setEnable(String enable) {
            this.enable = enable;
        }

        public Integer getLimitAllowExistNumber() {
            return this.limitAllowExistNumber;
        }

        public void setLimitAllowExistNumber(Integer limitAllowExistNumber) {
            this.limitAllowExistNumber = limitAllowExistNumber;
        }

        public Integer getMaxKeepNumber() {
            return this.maxKeepNumber;
        }

        public void setMaxKeepNumber(Integer maxKeepNumber) {
            this.maxKeepNumber = maxKeepNumber;
        }

        public Integer getPerRequestStep() {
            return this.perRequestStep;
        }

        public void setPerRequestStep(Integer perRequestStep) {
            this.perRequestStep = perRequestStep;
        }
    }


}

id获取及补充类

package com.felix.spring_cloud_one.util;

import com.felix.spring_cloud_one.config.ClientResult;
import com.felix.spring_cloud_one.config.IdGenerateProperties;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Configuration;

import javax.annotation.PostConstruct;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

@Configuration
public class IdTook {

    private static final Logger log = LoggerFactory.getLogger(IdTook.class);
    private static IdGenerateProperties idGenerateProperties;
    private static IdentGenerateClient identGenerateClient;
    private static final LinkedBlockingQueue<Long> IDENT_POOL = new LinkedBlockingQueue<>();
    //private static final LinkedBlockingQueue<Boolean> IDENT_POOL_LISTEN = new LinkedBlockingQueue<>();
    private static final ExecutorService SINGLE_THREAD_EXECUTOR;
    private static IdTook.ListenRunnable listenRunnable;


    static {
        SINGLE_THREAD_EXECUTOR = new ThreadPoolExecutor(1, 1, 0L, TimeUnit.MILLISECONDS, new LinkedBlockingQueue(), (r) -> {
            return new Thread(r, "id-took-thread");
        }, new ThreadPoolExecutor.DiscardOldestPolicy());
        listenRunnable = new IdTook.ListenRunnable();
    }

    public IdTook() {
    }

    @Autowired
    public void setIdentFeignClient(IdentGenerateClient identGenerateClient) {
        //从id生成服务获取id
        IdTook.identGenerateClient = identGenerateClient;
    }

    @Autowired
    public void setDrawerProperties(IdGenerateProperties idGenerateProperties) {
        IdTook.idGenerateProperties = idGenerateProperties;
    }

    @PostConstruct
    public void initIdentPool() {
        SINGLE_THREAD_EXECUTOR.execute(listenRunnable);
    }

    public static Long take() {
        log.info("当前取号池剩余:{}个号码", IDENT_POOL.size());

        try {
            if (0 == IDENT_POOL.size()) {
                log.warn("取号线程异常中断，当前系统直接从生成器获取id");
                ClientResult<Long> clientResult = identGenerateClient.make();
                if (1 == clientResult.getCode()) {
                    return (Long)clientResult.getData();
                }
            }

            Long id = (Long)IDENT_POOL.poll(10L, TimeUnit.SECONDS);
            if (IDENT_POOL.size() < idGenerateProperties.getIdentTooker().getLimitAllowExistNumber()) {
                synchronized(listenRunnable) {
                    listenRunnable.notify();
                }
            }

            return id;
        } catch (InterruptedException var4) {
            log.error(var4.getMessage(), var4);
            throw new RuntimeException("取号超时,请确保已启用id取号器功能");
        }
    }

    private static void offer(Long... ids) {
        Long[] var1 = ids;
        int var2 = ids.length;

        for(int var3 = 0; var3 < var2; ++var3) {
            Long id = var1[var3];

            try {
                IDENT_POOL.offer(id, 1L, TimeUnit.SECONDS);
            } catch (InterruptedException var6) {
                log.warn("插入新号码失败");
            }
        }

    }

    private static class ListenRunnable implements Runnable {
        private ListenRunnable() {
        }

        public void run() {
            while(true) {
                synchronized(IdTook.listenRunnable) {
                    if (IdTook.IDENT_POOL.size() > IdTook.idGenerateProperties.getIdentTooker().getLimitAllowExistNumber()) {
                        try {
                            IdTook.listenRunnable.wait();
                        } catch (InterruptedException var8) {
                            var8.printStackTrace();
                        }
                    } else {
                        IdTook.log.info("取号池号码过少，获取新号码");
                        Integer step = IdTook.idGenerateProperties.getIdentTooker().getPerRequestStep();
                        step = step > 100 ? 100 : step;
                        int count = (int)Math.ceil((double)(IdTook.idGenerateProperties.getIdentTooker().getMaxKeepNumber() / step));
                        count = 0 == count ? 1 : count;

                        for(int i = 0; i < count; ++i) {
                            ClientResult<Long []> clientResult = IdTook.identGenerateClient.make(step);
                            if (1 == clientResult.getCode()) {
                                Long[] data = clientResult.getData();
                                IdTook.offer(data);
                            }
                        }
                    }
                }
            }
        }
    }


}

yml配置文件

idsetting:
  identTooker:
    limitAllowExistNumber: 5
    maxKeepNumber: 5
    perRequestStep: 5