高并发高可用常用的单机方法

txxs

已于 2022-04-09 11:44:30 修改

阅读量490

点赞数

文章标签：系统架构 java

于 2022-04-09 11:43:54 首次发布

本文链接：https://blog.csdn.net/maoyeqiu/article/details/124058242

版权

一、限流

    public static class RateLimiterChangeHandler {

        private static final RateLimiter rateLimiter;

        static {
            rateLimiter = RateLimiter.create(getQueryLimitSpeed());
        }

        public static RateLimiter getRateLimiter() {
            int queryLimitSpeed = getQueryLimitSpeed();
            double curLimitSpeed = rateLimiter.getRate();
            if (curLimitSpeed != queryLimitSpeed) {
                rateLimiter.setRate(queryLimitSpeed);
            }
            return rateLimiter;
        }
    }
    
    //阻塞限流
    RateLimiterChangeHandler.getRateLimiter().acquire();
    //尝试获取令牌
    RateLimiterChangeHandler.getRateLimiter().tryAcquire()

二、线程池

private static ExecutorService executorService =  new ThreadPoolExecutor(10, 100, 60L, 
 								TimeUnit.SECONDS, new ArrayBlockingQueue<Runnable>(500), Executors.defaultThreadFactory(), new ThreadPoolExecutor.CallerRunsPolicy());
                
executorService.submit(new Runnable() {
            @Override
            public void run() {
                try {
    
                } catch (InterruptedException e) {
         
                } finally {
                
                }
            }
        });

三、重试

for (int retry = 0; retry < 3; retry++) {
     try {
         ……
         break;
      } catch (Exception e) {
        
      }
}

四、缓存

    private LoadingCache<String, Optional<City>> cityNameCache = CacheBuilder.newBuilder().maximumSize(5000)
            .expireAfterWrite(30, TimeUnit.MINUTES).build(new CacheLoader<String, Optional<City>>() {
                                                                                @Override
                                                                                public Optional<City> load(String cityName) {
                                                                                    return getCityByCityName(cityName);
                                                                                }
                                                                            });
                                                                            
    public Optional<City> getCityByCityName(@Nullable String cityName) {
        if (StringUtils.isBlank(cityName)) {
            return Optional.absent();
        }
        try {
            City city = cityService.getValidByCityName(cityName);
            if (null != city && city.getId() > 0) {
                return Optional.of(city);
            }
        } catch (Exception e) {
            logger.error(e);
        }
        return Optional.absent();

    }