Java Thread Sleep

I have a main for-loop that sends out requests to an e开发者_StackOverflowxternal system. The external system might take a few seconds or even minutes to respond back.

Also, if the number of requests reaches the MAX_REQUESTS, the current for-loop should SLEEP for a few seconds.

This is my scenario. Lets say the main for-loop goes to sleep say for 5 seconds because it has reached the MAX_REQUESTS. Then say a previous external requests comes back returns from callExternalSystem(). What will happen to the main for-loop Thread that is currently on the SLEEP state? Will it be interrupted and continue processing or continue to SLEEP?

for(...){
  ...
  while(numRequestsProcessing > MAX_REQUESTS){
     Thread.sleep(SLEEP_TIME);
  }
  ...
 callExternalSystem();

}

Thanks in advance.

---

Unless you've got some code to interrupt the sleeping thread, it will continue sleeping until the required time has elapsed. If you don't want that to happen, you could possibly use wait()/notify() instead of sleep() so that another thread can notify the object that the main thread is sleeping on, in order to wake it up. That relies on there being another thread to notice that the external system has responded, of course - it's not really clear how you're getting responses back.

EDIT: It sounds like really you should use a Semaphore. Each time the main thread wants to issue a request, it acquires a permit. Each time there's a response, that releases a permit. Then you just need to set it up with as many permits as you want concurrent requests. Use tryAcquire if you want to be able to specify a timeout in the main thread - but think about what you want to do if you already have as many requests outstanding as you're really happy with.

---

I would use java.util.concurrent.Executors to create a thread pool with MAX_REQUESTS threads. Create a java.util.concurrent.CountDownLatch for however many requests you're sending out at once. Pass the latch to the Runnables that make the request, they call countDown() on the latch when complete. The main thread then calls await(timeout) on the latch. I would also suggest the book "Java Concurrency in Practice".

---

One approach, is to use a ThreadPoolExecutor which blocks whenever there is no free thread.

ThreadPoolExecutor executor = new ThreadPoolExecutor(MAX_REQUESTS, MAX_REQUESTS, 60, TimeUnit.SECONDS, new SynchronousQueue<Runnable>(), new RejectedExecutionHandler() {
    @Override
    public void rejectedExecution(Runnable r, ThreadPoolExecutor executor) {
        try {
            executor.getQueue().offer(r, Long.MAX_VALUE, TimeUnit.NANOSECONDS);
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }
    }
});
for(int i=0;i<LOTS_OF_REQUESTS;i++) {
    final int finalI = i;
    executor.submit(new Runnable() {
        @Override
        public void run() {
            request(finalI);
        }
    });
}

Another approach is to have the tasks generate their own requests. This way a new request is generated each time a thread is free concurrently.

ExecutorService executor = Executors.newFixedThreadPool(MAX_REQUESTS);
final AtomicInteger counter = new AtomicInteger();
for (int i = 0; i < MAX_REQUESTS; i++) {
    executor.submit(new Runnable() {
        @Override
        public void run() {
            int i;
            while ((i = counter.getAndIncrement()) < LOTS_OF_REQUESTS)
                request(i);
        }
    });
}