如何限制任务，以便一次只运行一个任务，然后忽略休息

Question

I have an object that listens to external events. Upon receiving an event, my object needs to execute a task (a Runnable ). However, there is a restriction:

Once the task starts executing, I should not start other tasks (I can ignore them) until original task is finished and certain amount of time passed after that (throttling).

Here's suggested implementation using semaphore :

public class Sample {

    private final Semaphore semaphore = new Semaphore(1);

    private final ScheduledExecutorService executor;

    public Sample(ScheduledExecutorService executor) {
        this.executor = executor;    
    }

    public void tryRun() {
        if (semaphore.tryAcquire()) {
            try {
                executor.submit(
                    new Runnable() {
                        @Override
                        public void run() {
                            try {
                                doIt();
                            } finally {
                                try {
                                    executor.schedule(
                                        new Runnable() {
                                            @Override
                                            public void run() {
                                                semaphore.release();
                                            }
                                        },
                                        1, 
                                        TimeUnit.MINUTES
                                    );
                                } catch (Throwable t) {
                                    semaphore.release();
                                }
                            }
                        }
                    }
                );
            } catch (Throwable t) {
                semaphore.release();            
            }
        }
    }

    private void doIt() {
        // the exact task executing logic is here
    }
}

The code seems too verbose to me. Is there a better way of doing this?

PS Another restriction is that ScheduledExecutorService is the only interface I have to the external executor and I cannot start my own threads/executors within my object

Answer 1

Just use a ThreadPoolExecutor with a single thread. You'll have to decide whether it's okay to queue up a lot of the other tasks. If not, pass it your own BlockingQueue with capacity 1, I believe this will let at most one task queue up. I'm thinking about how to get that down to zero.

One way to create a single threaded executor with unbounded queue.

Note you will need to configure the TPE to discard rejected tasks via a DiscardPolicy .

Answer 2

+1 to @djechlin. That's the right answer. To add the implementation:

ExecutorService threadPool =
   new ThreadPoolExecutor(1, 1, 0L, TimeUnit.MILLISECONDS,
       new SynchronousQueue<Runnable>(), new ThreadPoolExecutor.DiscardPolicy());

To go back to your question.

Once the task starts executing, I should not start other tasks (I can ignore them) until original task is finished and certain amount of time passed after that (throttling).

This starts 1 and only 1 thread, uses a synchronous-queue and the DiscardPolicy which will discard any tasks unless the thread is waiting to run it. If the single thread is working then any tasks submitted to the pool will be rejected and sent to the rejection policy. In your case you want to just discard them.

If you really want to queue the tasks if the working thread is busy, then you should use a bounded LinkedBlockingQueue instead. Maybe with a rejection policy that blocks the caller when the queue is full.

Something like the following:

ExecutorService threadPool =
   new ThreadPoolExecutor(1, 1, 0L, TimeUnit.MILLISECONDS,
      new LinkedBlockingQueue<Runnable>(10), new RejectedExecutionHandler() {
         public void rejectedExecution(Runnable r, ThreadPoolExecutor executor) {
           // this will block the caller until the queue has space
           executor.getQueue().add(r);
         }
      });