将调用频率限制为静态方法

Question

我们有一个从多个线程调用并访问外部数据库的方法。为了不减慢其他客户端的数据库速度，对该方法的调用应限制为 1 次/秒。

我喜欢保持简单，所以我这样做了：

private static final Object SYNC_LOCK = new Object();

public static double myMethod(int param1, ...) {
  synchronized(SYNC_LOCK) {
    //do something...
    Thread.sleep(1000);
    return result;
  }
}

现在，我们正在使用 sonarqube 进行代码分析，这种睡眠被视为“阻塞”错误。 通过查看代码，我可以排除死锁。实现一种基于令牌的方法对我来说似乎有点多。

您是否同意 sonarqube 需要更改此代码？

现在，我们可以使用例如线程池来实现如下所述。但对我来说，第一个例子似乎更圆滑。

private static ExecutorService es = Executors.newFixedThreadPool(1);
private static long lastCall = 0;

public static Double myMethod(int param1, ...) {
    Future<Double> f = es.submit(new Callable<Double>() {
        @Override
        public Double call() throws Exception {
            long diff = System.currentTimeMillis() - lastCall;
            if (diff < 1000) {
                long sleepMillis = 1000 - diff;
                Thread.sleep(sleepMillis);
            }
            //do something...
            lastCall = System.currentTimeMillis();
            return result;
        }
    });
    try {
        return f.get();
    } catch (InterruptedException | ExecutionException e) {
        //handle this
        return null;
    }
}

Answer 1

我想这是一种有效的创可贴。但它会产生一个瓶颈，即一次只有一个请求可以取得进展。对于您的客户来说，他们必须预先支付时间罚金，而不是您检查自上次请求以来是否有足够的时间过去，这对您的客户来说也是粗暴的。

Sonarqube 是一个静态分析工具，它所能做的就是找到代码中的模式并将规则应用于它们。一般来说，不带锁睡觉的规则很有意义。 当一个线程持有锁时，其他线程显然被阻塞，并且当一个线程处于睡眠状态时它没有工作，所以它显然不是最佳的。在很多情况下，您会看到程序员添加睡眠是为了避免丢失通知和其他错误而绝望（且不明智）的尝试，我认为这就是 Sonarqube 试图标记的。

首先，由于访问外部数据库是一个痛点，并且您想减轻它的负载，因此请尝试尽可能多地缓存结果。

当您使用 ThreadPoolExecutor 时，您可以通过配置工作人员的数量、设置拒绝策略等来更好地控制工作速率。一旦缓存减少了外部数据库上的负载，您就需要多个请求有时，您可以调整工作线程的数量以提高吞吐量。

Answer 2

用其他方法提取业务逻辑（比如下面的myExpensiveMethod()）然后考虑实现客户端Rate Limiter（我假设并发调用没有副作用）-

RateLimiterConfig config = RateLimiterConfig.custom()
  .limitForPeriod(1)
  .limitRefreshPeriod(Duration.ofSeconds(1))
  .timeoutDuration(Duration.ofSeconds(1))
  .build();

然后从myMethod() 致电myExpensiveMethod()

public static Double myMethod() {

  RateLimiterRegistry registry = RateLimiterRegistry.of(config);
  RateLimiter limiter = registry.rateLimiter("myMethod");
  Supplier<Double> dbQuerySupplier = 
       RateLimiter.decorateSupplier(limiter,
                  () -> myExpensiveMethod());
  return dbQuerySupplier.get();
}

Answer 3

IMO 最简单的方法是做这样的事情（请原谅伪库调用）：

public static double myRealMethod() {
  synchronized(SYNC_LOCK) {
    //do something...
    Thread.sleep(1000);
    return result;
  }
}

private static double cachedResult;
private static Somekindoftimestamp cachedResultDate = A_LONG_TIME_AGO;
public static double myMethod() {
  synchronized(SYNC_LOCK) {
    if (cachedResultDate.isTooOldForMyLiking()) {
      cachedResult = myRealMethod();
    }
    return cachedResult;
  }
}

一个明显的缺点：某些对myMethod() 的调用会比其他大多数调用花费更长的时间。

---

一个可能的改进（取决于您的应用程序的需要）：让myMethod()总是返回缓存的结果，并创建一个周期性的Timer 任务，每秒调用一次myRealMethod() 以更新是否需要缓存结果。