java限制并发数

经测试，1秒内可能出现2倍限制的返回量，望各位大佬指正，本文方案仅供参考

方案1：

    private LoadingCache<Long, AtomicLong> counter =
            CacheBuilder.newBuilder()
                    .expireAfterWrite(1, TimeUnit.SECONDS)  //1秒内
                    .build(new CacheLoader<Long, AtomicLong>() {
    
    
                        @Override
                        public AtomicLong load(Long seconds) throws Exception {
    
    
                            return new AtomicLong(0);
                        }
                    });
    //每秒限制次数
    public static long permit = 2;
    
    public Integer mmm() {
    
    
        long currentSeconds = System.currentTimeMillis() / 1000;
        long current = 0;
        try {
    
    
            current = counter.get(currentSeconds).incrementAndGet();
        } catch (ExecutionException e) {
    
    
            return -1
        }
        if (current > permit) {
    
    
            return -2
        }
        //todo 逻辑业务
        return 1;
    }

方案2：

    private static Semaphore semaphore = new Semaphore(2);//限制并发个数

    public Integer mmm() {
    
    
        if (!semaphore.tryAcquire()) {
    
    
            return new Result(ResultCode.REQUEST_OFTEN);
        }
        try {
    
    
            //todo 逻辑业务
            return 1;
        } catch (Exception e) {
    
    
            return -1;
        } finally {
    
    
            semaphore.release();
        }
    }