防止多个异步调用同时进行而不会阻塞

Question

Here's essentially my problem:

while (true) {
  if (previous 'doWorkAsync' method is not still in flight) {
    doWorkAsync()  // this returns immediately
  }
  wait set amount of time
}

A couple solutions come to mind for me:

1. Block until doWorkAsync() completes. This is not desirable to me for a few reasons. It (potentially) results in waiting longer than I really needed to in the 'wait some set amount of time' line (eg if doWorkAsync takes 5 seconds, and the set amount of waiting time is 10 seconds, this will result in 15 seconds of waiting between calls, which isn't what I wanted). Of course, I could account for this by waiting less time, but somehow it just feels clunky. It also ties up this thread unnecessarily. Instead of waiting for this task to come back, this thread could handle other work, like making config updates so the next call to doWorkAsync() has fresh data.

2. Use a gating mechanism. The easiest implementation that comes to mind is a boolean, set before calls to doWorkAsync(), and unset when doWorkAsync() completes. This is essentially what I'm doing now, but I'm not sure if it's an anti-pattern??

Is #2 the right way to go, or are there better ways to solve this problem?

EDIT : If it helps, doWorkAsync() returns a ListenableFuture (of guava).

The original question may not have been 100% clear. Here's the crux. If the async request finishes before the given timeout, this code will always work. However, if the async task takes SET_AMOUNT_OF_TIME + epsilon to complete, then this code will sleep twice as long as necessary, which is what I'm trying to avoid.

Answer 1

The simplest way to do this is using the wait and notifyAll methods already in Java. All you need to do is use an AtomicBoolean as a flag and block on it until the another Thread tells you something has changed.

The difference between that and your approach is that a blocked thread doesn't do anything whereas a polling thread uses CPU time.

Here is a simple example using two Thread s - the Runnable " First " is submitted and it waits on done until the Runnable " Second " notifies that it has changed the flag.

public class App {

    private static final AtomicBoolean done = new AtomicBoolean(false);

    private static final class First implements Runnable {

        @Override
        public void run() {
            while (!done.get()) {
                System.out.println("Waiting.");
                synchronized (done) {
                    try {
                        done.wait();
                    } catch (InterruptedException ex) {
                        return;
                    }
                }
            }
            System.out.println("Done!");
        }
    }

    private static final class Second implements Runnable {

        @Override
        public void run() {
            try {
                Thread.sleep(1000);
            } catch (InterruptedException ex) {
                return;
            }
            done.set(true);
            synchronized (done) {
                done.notifyAll();
            }
        }
    }

    public static void main(String[] args) throws InterruptedException {
        final ExecutorService executorService = Executors.newFixedThreadPool(2);

        executorService.submit(new First());
        Thread.sleep(1000);
        executorService.submit(new Second());
        executorService.shutdown();

    }
}

The sleep calls are just to show that a task of arbitrary length can take place, obviously they are not required.

The thing to note is that First prints "waiting" every time it enters the loop and, if you run the code, it only prints it once. The second thing to note is that First reacts to the changing of the flag immediately as it is told to awake and recheck when the flag is changed.

I have used return in the InterruptedException blocks, you may want to used Thread.currentThread().interrupt() instead so that the process doesn't die if it's spuriously interrupted.

A more advanced approach is to use Lock and Condition

public class App {

    private static final Lock lock = new ReentrantLock();
    private static final Condition condition = lock.newCondition();

    private static final class First implements Runnable {

        @Override
        public void run() {
            lock.lock();
            System.out.println("Waiting");
            try {
                condition.await();
            } catch (InterruptedException ex) {
                return;
            } finally {
                lock.unlock();
            }
            System.out.println("Done!");
        }
    }

    private static final class Second implements Runnable {

        @Override
        public void run() {
            lock.lock();
            try {
                Thread.sleep(1000);
                condition.signalAll();
            } catch (InterruptedException ex) {
                return;
            } finally {
                lock.unlock();
            }
        }
    }

    public static void main(String[] args) throws InterruptedException {
        final ExecutorService executorService = Executors.newFixedThreadPool(2);

        executorService.submit(new First());
        Thread.sleep(1000);
        executorService.submit(new Second());
        executorService.shutdown();

    }
}

In this situation First acquires a lock on the Lock object the immediately calls await on the Condition . The releases the lock and blocks on the Condition .

Second then acquires a lock on the Lock and calls signalAll on the Condition which awakes First .

First then reacquires the lock and continues execution, printing "Done!".

EDIT

The OP would like to call the method doWorkAsync with a specified period, if the method takes less time than the period then the process has to wait. If the method takes longer then the method should be called again immediately after.

The task needs to be stopped after a certain time.

At no point should the method be running more than once simultaneously.

The easiest approach would be to call the method from a ScheduledExecutorService , the Runnable would wrap the method and call get on the Future - blocking the scheduled executor until it is done.

This guarantees that the method is called with at least WAIT_TIME_BETWEEN_CALLS_SECS delay.

Then schedule another task that kills the first one after a set time.

final ScheduledExecutorService scheduledExecutorService = Executors.newSingleThreadScheduledExecutor();
final Future<?> taskHandle = scheduledExecutorService.scheduleAtFixedRate(new Runnable() {
    @Override
    public void run() {
        final ListenableFuture<Void> lf = doWorkAsync();
        try {
            doWorkAsync().get();
        } catch (InterruptedException ex) {
            Thread.currentThread().interrupt();
        } catch (ExecutionException ex) {
            throw new RuntimeException(ex);
        }
    }
}, 0, WAIT_TIME_BETWEEN_CALLS_SECS, TimeUnit.SECONDS);
scheduledExecutorService.schedule(new Runnable() {
    @Override
    public void run() {
        taskHandle.cancel(false);
    }
}, TOTAL_TIME_SECS, TimeUnit.SECONDS);

The best solution would be call the raw Runnable on a ScheduledExecutorService rather than calling it on another executor and blocking on the ListenableFuture .

Answer 2

Think what you are looking for is The Reactor Pattern .

Is there a reason you don't want these things running at the same time? If what you want to do is chain them, you could use Futures. Akka has Composable Futures and mappable ones.