Restricting thread count and Java concurrency

I think a thread pool is what you are looking for. Take a look at ExecutorService and Executors.

ExecutorService : http://docs.oracle.com/javase/6/docs/api/java/util/concurrent/ExecutorService.html

Executors : http://docs.oracle.com/javase/6/docs/api/java/util/concurrent/Executors.html

Getting a new Thread fixed thread-pool that processes max. 10 Thread at once :

ExecutorService threadPool = Executors.newFixedThreadPool(10);

With the submit Method you pass Callables or Runnables to the Pool.

For your use case you need a process that looks into the Queue, if there is a new request a Callable or Runnable has to be created and passed to the thread-pool. The pool ensures that max. 10 threads are executed at once.

This is a very small tutorial : http://www.math.uni-hamburg.de/doc/java/tutorial/essential/threads/group.html

A nice thing working with thread-pools is that the submit method returns a Future object, which supports return types for the executed threads.

Future : http://docs.oracle.com/javase/6/docs/api/java/util/concurrent/Future.html

I hope this helps you to solve your problem.

I had the same task: I used the BlockingQueue of the java.util.concurrent package. I created X worker threads which reads one action from the queue, processes it, and when ready take the next. This is simple, and it works fine.

If you use X = 10 Worker threads, then your task is solved.

Looks like you need a thread pool executor with corePoolSize=0 and maximumPoolSize=10.

http://docs.oracle.com/javase/6/docs/api/java/util/concurrent/ThreadPoolExecutor.html

If you don't actually have access to the creation of the threads, and you only manage the queue access, a solution could simply be to use a Semaphore object (see the docs page).

The idea is for a global semaphore, accessed in the same way the queue is accessed, to be initialized to the number max_threads (say, 10).

Before accessing the queue for item processing, a thread would first acquire a permit from the semaphore, which would block if a max_threads number of threads had already started processing items from the queue.

After an item is processed by some thread, that thread should finally release the permit, thus allowing more threads to process other items.

Note that the acquiring/releasing of a permit should be done using a try-finally block, so that even if some exception is thrown from the item processing, the semaphore remains in a consistent state. The code should look like this:

semaphore.acquire().
try {
    // retrieve item from queue and process it
}
finally {
    semaphore.release();
}