在线程之间造成延迟

Question

所有，我有一个由许多线程调用的api调用。 唯一的问题是延迟下注。 线程应至少为1秒。 我意识到-没有同步块-如果一个线程在时间t1调用api，则所有其他线程等待1秒，然后所有其他线程在t1 + 1秒调用api。 这不是我想要的，因此，只要一个线程正在等待所有其他线程块，就将整个等待块放在同步块中。

这有效； 但是，我认为这不是最有效的方法。

任何建议，不胜感激。

private static volatile AtomicLong lastAPICall = new AtomicLong();

private void callAPI() {

  // 1 sec plus a little extra
  final long oneMS = 1 * 1000 + 100;            
  long lastCall = 0;
  long timeDiff = 0;

  synchronized (lastAPICall) {
       timeDiff = System.currentTimeMillis() - lastAPICall.get();
       lastCall = lastAPICall.getAndSet(System.currentTimeMillis());
   }
}

if (System.currentTimeMillis() - lastCall < oneMS) {
    synchronized (lastAPICall) {
            try {
                long sleep = oneMS - timeDiff;
                Thread.sleep(oneMS - timeDiff);
            } catch (InterruptedException ignore) {}
            finally {
               lastAPICall.set(System.currentTimeMillis());
               log.info("Thread: " + Thread.currentThread().getId() + " calling the api at this time: " +   System.currentTimeMillis());
        }
  }
}

try {
// API CALL
}
catch (IOException t){
            throw t;
} finally {
   synchronized (lastAPICall) {
     lastAPICall.set(System.currentTimeMillis());   
  }
}

// Log files for running the code with 4 threads
Thread: 35 calling the api at this time: 1456182353694
Thread: 34 calling the api at this time: 1456182354795
Thread: 37 calling the api at this time: 1456182355905
Thread: 36 calling the api at this time: 1456182357003

Answer 1

如果要允许以某种速率调用API。 同样，您不需要静态原子的挥发物。 如果您在同步块中使用原子，则不需要原子。

private static final long MAX_RATE = 1000;
private static final Semaphore API_CALL_SEMAPHORE = new Semaphore(1);
private volatile long lastCall;

public void callApi() throws IOException, InterruptedException {
    try {
        API_CALL_SEMAPHORE.acquire();
        delayedCall();
    } catch (IOException | InterruptedException e) {
        throw e;
    } finally {
        API_CALL_SEMAPHORE.release();
    }
}

private void delayedCall() throws InterruptedException, IOException {
    long tryCallTime = System.currentTimeMillis();
    final long deltaTime = tryCallTime - lastCall;
    if (deltaTime < MAX_RATE){
        final long sleepTime = MAX_RATE - deltaTime;
        Thread.sleep(sleepTime);
        tryCallTime += sleepTime;
    }
    // API CALL
    lastCall = tryCallTime; // if you want to delay only succeed calls.
}