id本地缓存策略

Posted 2022-02-04 好大的月亮

思路是每次去生成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