Using AsyncEventHandlers as a RTJ buildin thread pool

Hi David
1. I would like to use AsyncEventHandler mechanism as a thread pool. Would there be a way in future version to access the AsyncEventHandler's RT Thread pool API ?
2. I am using the BoundAsyncEventHandler for long duration task (since the BoundAsyncEventHandler is bound to a specific Thread) - Would there be a way in future version to bound a specific RT Thread to this handler ? - for example a RT Thread that was created by my own Thread pool ?
Thanks

Gabi wrote:
1.We need our code to access the AEH's "thread pool" and check the pool's availability; increase/decrease the pool size dynamically; check pool size for enough free threads to run any given number of tasks and so on...There are no API's for this. How a VM supports AEH execution is an implementation detail, and while a "pool" is the logical form of implementation the details can vary significantly so there's no real way to define an API to control it without defining what form it must take. For example in Java RTS the pool threads are initially at the highest system priority and then drop down to the priority of the AEH they execute. In a different design you might have a pool of threads per priority level (or set of priority levels) so even the notion of increasing/decreasing the pool size is not necessarily straight-forward. In Java RTS the pool will grow as needed to service outstanding AEH activations. You can control the initial number of threads - and there are two pools: one of heap-using and one for non-heap AEH.
2. I was thinking about adding the BAEH class with the next method:
void setBoundThread(RTThread t) throws IllegalArgumentExceptionand also in the Ctor add the RTThread as a parameter.
Inside this method, the thread should be check if started and is so should throw an IllegalArgumentException.Sure, but why do you need to do this? What is different about the RTT that you pass in? The thread executing an AEH acquires the characteristics of the AEH.
An API like this raises some questions such as: when would the thread be started? It also has a problem in that the run() method of the thread has to know how to execute an AEH, which means we'd (the RTSJ expert group) probably have to define a class BoundAEHThread that has a final run() method and you'd then subclass it.
3. Additional question, what do you think about using lock (CountdownLatch) during the AEH's executions ?
I've seen somewhere that AEH should only be used for short live tasks - is it true ? (in the JavaDoc it says there is no problem doing so but I want to be sure)If an AEH blocks for any length of time and additional AEH are activated then the pool management overhead may increase (unless you already sized it appropriately). But otherwise there's no restriction on what the code in an AEH can do. But note that none of the java.util.concurrent synchronization tools support priority-inversion avoidance, so you need to be careful if using them (ie only use them across threads of the same priority and don't expect FIFO access).
David Holmes

Similar Messages

A good design for a single thread pool manager using java.util.concurrent

Hi,
I am developing a client side project which in distinct subparts will execute some tasks in parallel.
So, just to be logorroic, something like that:
program\
            \--flow A\
                       \task A1
                       \task A2
            \--flow B\
                        \task B1
                        \task B2
                        \...I would like both flow A and flow B (and all their launched sub tasks) to be executed by the same thread pool, because I want to set a fixed amount of threads that my program can globally run.
My idea would be something like:
public class ThreadPoolManager {
    private static ExecutorService executor;
    private static final Object classLock = ThreadPoolManager.class;
     * Returns the single instance of the ExecutorService by means of
     * lazy-initialization
     * @return the single instance of ThreadPoolManager
    public static ExecutorService getExecutorService() {
        synchronized (classLock) {
            if (executor != null) {
                return executor;
            } else {
                // TODO: put the dimension of the FixedThreadPool in a property
                executor = Executors.newFixedThreadPool(50);
            return executor;
     * Private constructor: deny creating a new object
    private ThreadPoolManager() {
}The tasks I have to execute will be of type Callable, since I expect some results, so you see an ExecutorService interface above.
The flaws with this design is that I don't prevent the use (for example) of executor.shutdownNow(), which would cause problems.
The alternative solution I have in mind would be something like having ThreadPoolManager to be a Singleton which implements ExecutorService, implementing all the methods with Delegation to an ExecutorService object created when the ThreadPoolManager object is instantiated for the first time and returned to client:
public class ThreadPoolManager implements ExecutorService {
    private static ThreadPoolManager pool;
    private static final Object classLock = ThreadPoolManager.class;
    private ExecutorService executor;
     * Returns the single instance of the ThreadPoolManager by means of
     * lazy-initialization
     * @return the single instance of ThreadPoolManager
    public static ExecutorService getThreadPoolManager() {
        synchronized (classLock) {
            if (pool !=null) {
                return pool;
            } else {
                // create the real thread pool
                // TODO: put the dimension of the FixedThreadPool in a property
                // file
                pool = new ThreadPoolManager();
                pool.executor = Executors.newFixedThreadPool(50);
                // executor = Executors.newCachedThreadPool();
                return pool;
     * Private constructor: deny creating a new object
    private ThreadPoolManager() {
    /* ======================================== */
    /* implement ExecutorService interface methods via delegation to executor
     * (forbidden method calls, like shutdownNow() , will be "ignored")
      // .....I hope to have expressed all the things, and hope to receive an answer that clarifies my doubts or gives me an hint for an alternative solution or an already made solution.
ciao
Alessio

Two things. Firstly, it's better to use     private static final Object classLock = new Object();because that saves you worrying about whether any other code synchronises on it. Secondly, if you do decide to go for the delegation route then java.lang.reflect.Proxy may be a good way forward.

How to correctly use a fixed size thread pool?

I am quite new to using concurrency in Java, so please forgive if this is a trivial question.
I would like to make use of something like pool=Executors.newFixedThreadPool(n) to automatically use a fixed number of threads to process pieces of work. I understand that I can asynchronously run some Runnable by one of the threads in the threadpool using pool.execute(someRunnable).
My problem is this: I have some fixed amount of N datastructures myDS (which are not reentrant or sharable) that get initialized at program start and which are needed by the runnables to do the work. So, what I really would like to do is that I not only reuse N threads but also N of these datastructures to do the work.
So, lets say I want to have 10 threads, then I would want to create 10 myDS objects once and for all. Each time some work comes in, I want that work to get processed by the next free thread, using the next free datastructure. What I was wondering is if there is something in the library that lets me do the resusing of threads AND datastructures as simply as just reusing a pool of threads. Ideally, each thread would get associated with one datastructure somehow.
Currently I use an approach where I create 10 Runnable worker objects, each with its own copy of myDS. Those worker objects get stored in an ArrayBlockingQueue of size 10. Each time some work comes in, I get the next Runner from the queue, pass it the piece of work and submit it to the thread pool.
The tricky part is how to get the worker object back into the Queue: currently I essentially do queue.put(this) at the very end of each Runnable's run method but I am not sure if that is safe or how to do it safely.
What are the standard patterns and library classes to use for solving this problem correctly?

Thank you for that feedback!
There is one issue that worries me though and I obviously do not understand it enough: as I said I hand back the Runnable to the blocking queue at the end of the Runnable.run method using queue.put(this). This is done via a static method from the main class that creates the threads and runnable objects in a main method. Originally I tried to make that method for putting back the Runnable objects serialized but that inevitably always led to a deadlock or hang condition: the method for putting back the runnable was never actually run. So I ended up doing this without serializing the put action in any way and so far it seems to work ... but is this safe?
To reiterate: I have a static class that creates a thread pool object and a ArrayBlockingQueue queue object of runnable objects. In a loop I use queue.take() to get the next free runnable object, and pass this runnable to pool.execute. Inside the runnable, in method run, i use staticclass.putBack(this) which in turn does queue.put(therunnableigot). Can I trust that this queue.put operation, which can happen from several threads at the same time works without problem without serializing it explicitly? And why would making the staticclass.putBack method serialized cause a hang? I also tried to serialize using the queue object itself instead of the static class, by doing serialize(queue) { queue.put(therunnable) } but that also caused a hang. I have to admit that I do not understand at all why that hang occurred and if I need the serialization here or not.

How can I use the same thread pool implementation for different tasks?

Dear java programmers,
I have written a class which submits Callable tasks to a thread pool while illustrating the progress of the overall procedure in a JFrame with a progress bar and text area. I want to use this class for several applications in which the process and consequently the Callable object varies. I simplified my code and looks like this:
        threadPoolSize = 4;
        String[] chainArray = predock.PrepareDockEnvironment();
        int chainArrayLength = chainArray.length;
        String score = "null";
        ExecutorService executor = Executors.newFixedThreadPool(threadPoolSize);
        CompletionService<String> referee = new ExecutorCompletionService<String>(executor);
        for (int i = 0; i < threadPoolSize - 1; i++) {
            System.out.println("Submiting new thread for chain " + chainArray);
referee.submit(new Parser(chainArray[i]));
for (int chainIndex = threadPoolSize; chainIndex < chainArrayLength; chainIndex++) {
try {
System.out.println("Submiting new thread for chain " + chainArray[chainIndex]);
referee.submit(new Parser(chainArray[i]));
score = referee.poll(10, TimeUnit.MINUTES).get();
System.out.println("The next score is " + score);
executor.shutdown();
int index = chainArrayLength - threadPoolSize;
score = "null";
while (!executor.isTerminated()) {
score = referee.poll(10, TimeUnit.MINUTES).get();
System.out.println("The next score is " + score);
index++;
My question is how can I replace Parser object with something changeable, so that I can set it accordingly whenever I call this method to conduct a different task?
thanks,
Tom

OK lets's start from the beginning with more details. I have that class called ProgressGUI which opens a small window with 2 buttons ("start" and "stop"), a progress bar and a text area. It also implements a thread pool to conducts the analysis of multiple files.
My main GUI, which is much bigger that the latter, is in a class named GUI. There are 3 types of operations which implement the thread pool, each one encapsulated in a different class (SMAP, Dock, EP). The user can set the necessary parameters and when clicking on a button, opens the ProgressGUI window which depicts the progress of the respective operation at each time step.
The code I posted is taken from ProgressGui.class and at the moment, in order to conduct one of the supported operations, I replace "new Parser(chainArray)" with either "new SMAP(chainArray[i])", "new Dock(chainArray[i])", "new EP(chainArray[i])". It would be redundant to have exactly the same thread pool implementation (shown in my first post) written 3 different times, when the only thing that needs to be changed is "new Parser(chainArray[i])".
What I though at first was defining an abstract method named MainOperation and replace "new Parser(chainArray[i])" with:
new Callable() {
public void call() {
    MainOperation();
});For instance when one wants to use SMAP.class, he would initialize MainOperation as:
public abstract String MainOperation(){
    return new SMAP(chainArray));
That's the most reasonable explanation I can give, but apparently an abstract method cannot be called anywhere else in the abstract class (ProgressGUI.class in my case).
Firstly it should be Callable not Runnable.Can you explain why? You are just running a method and ignoring any result or exception. However, it makes little difference.ExecutorCompletionService takes Future objects as input, that's why it should be Callable and not Runnable. The returned value is a score (String).
Secondly how can I change that runMyNewMethod() on demand, can I do it by defining it as abstract?How do you want to determine which method to run?The user will click on the appropriate button and the GUI will initialize (perhaps implicitly) the body of the abstract method MainOperation accordingly. Don't worry about that, this is not the point.
Edited by: tevang2 on Dec 28, 2008 7:18 AM

[svn] 1605: Bug: BLZ-155 - Deadlock using a thread pool for tomcat connectors

Revision: 1605
Author: [email protected]
Date: 2008-05-07 14:24:53 -0700 (Wed, 07 May 2008)
Log Message:
Bug: BLZ-155 - Deadlock using a thread pool for tomcat connectors
QA: Yes - Jorge verified in the QE lab
Doc: No
Ticket Links:
http://bugs.adobe.com/jira/browse/BLZ-155
Modified Paths:
blazeds/branches/3.0.x/modules/core/src/java/flex/messaging/client/EndpointPushNotifier.j ava

Cross post: http://forum.java.sun.com/thread.jspa?threadID=5215686&tstart=0
If you must post across forums, just post in the most relevant one and then give the link to that in the other posts.

How to use thread pool in glassfish

I am using jdk 1.6 with glassfish 2.1
in admin console i found threadpools under Configuration> Thread Pools
my questions are
is this thread pool is accessible to programmers (just like in websphere threadpool is accessible to programmers through work manager and asynch beans)
can I do the same thing using glassfish (eg. WorkManager wm = new WorkManager(_threadpool_) )
or is there any other way to do this.
Is there any way to use the threads in the threadpool to run some batch job in parallel?
what exactly the purpose of this threadpool in glassfish, I mean it used internally bu glassfish or programmers have to use it explicitly in there code

It is pretty straight forward. You just create an executor instance and feed it runnable objects. For example:
import java.util.concurrent.*;
public class ExecutorExample {
    static class Worker implements Runnable {
        public Worker(int id) {
            this.id = id;
        public void run() {
            for(int i = 0; i < 100; i++) {
                System.out.printf("Thread %d iteration %d of 100%n", id, i);
                try {
                    Thread.sleep(100);
                catch(Exception e)
        private int id;
    public static void main(String[] args) {
        BlockingQueue<Runnable> queue = new ArrayBlockingQueue<Runnable>(200);
        Executor e = new ThreadPoolExecutor(10, 10, 1, TimeUnit.SECONDS, queue);
        System.out.println("Creating workers");
        for(int i = 0; i < 20; i++)
            e.execute(new Worker(i));
        System.out.println("Done creating workers");
}

Thread Pool in JRT

Hi All,
1) the first question is what is the recommended way to allocate thread poll in rt system??
2) what is the best way to do:
-if my mission take a long time can i just suspend the thread and than resume it again (is it possible at all??)
or the other option is to return it to the pool and get it again and again.
im asking the second question from the view of performance and low latency .
i assumed that each time i return the thread to the pool and than active it again it will "cost" cpu time.
hope my question is clear enough.
TIA
Gabi

Hi Gabi,
I'm not completely clear on your questions. You can create a thread pool in a RT system the same basic way as in non-RT but you need to deal with priorities correctly. One way to do this would be to have the pool threads run at maximum priority normally and then drop to the actual priority of a submitted work task. Another model is to split the pool into groups based on priority, so effectively there is a work queue per priority-level and a group of threads to service each pool. This second model is used in the Real-time CORBA "lanes" approach. Designing an effective thread pool is a non-trivial task (take a look at the java.util.concurrent Thread PoolExecutor) and dealing with RT priorities and RT latency issues makes it even more complex.
Alternatively rather than use an explicit thread pool consider whether you can convert the design to one using AsyncEvents and AsyncEventHandlers.
Question 2 I don't really understand. Pool threads typically block on a queue waiting for work tasks to appear. But you can also have a non-terminating task that effectively picks up its own work from elsewhere - eg a task that reads from a socket to get the next "job" to process. Any interaction between threads is going to cost CPU time, whether a pool is involved or not, but yes there will be overhead associated with a pool, just as there is starting and terminating a thread, or performing any kind of thread coordination/synchronization.
Regards,
David Holmes

JRun Thread Pool Issue

I'm running CF 9.0.1 on Ubuntu on an "Medium" Amazon EC2 instance. CF has been crashing intermittently (several times per day). At such times, running top gets me this (or something similar):
PID
USER
PR
NI
VIRT
RES
SHR
S
%CPU
%MEM
TIME+COMMAND
15855
wwwrun
20
0
1762m
730m
20m
S
99.3
19.4
13:22.96 coldfusion9
So, it's obviously consuming most of the server resources. The following error has been showing up in my cfserver.log in the leadup to each crash:
java.lang.RuntimeException: Request timed out waiting for an available thread to run. You may want to consider increasing the number of active threads in the thread pool.
If I run /opt/coldfusion9/bin/coldfusion status, I get:
Pg/Sec DB/Sec CP/Sec Reqs Reqs Reqs AvgQ   AvgReq AvgDB Bytes Bytes
Now Hi Now Hi Now Hi Q'ed Run'g TO'ed Time   Time   Time   In/Sec Out/Sec
0   0   0   0   -1 -1 150   25    0     0      -1352560      0      0
In the administrator, under Server Settings > Request Tuning, the setting for Maximum number of simultaneous Template requests is 25. So this makes sense so far. I could just increase the thread pool to cover these sort of load spikes. I could make it 200. (Which I did just now as a test.)
However, there's also this file /opt/coldfusion9/runtime/servers/coldfusion/SERVER-INF/jrun.xml. And some of the settings in there appear to conflict. For example, it reads:
<service class="jrunx.scheduler.SchedulerService" name="SchedulerService">
<attribute name="bindToJNDI">true</attribute>
<attribute name="activeHandlerThreads">25</attribute>
<attribute name="maxHandlerThreads">1000</attribute>
<attribute name="minHandlerThreads">20</attribute>
<attribute name="threadWaitTimeout">180</attribute>
<attribute name="timeout">600</attribute>
</service>
Which a) has fewer active threads (what does this mean?), and b) has a max threads that exceed the simultaneous request limit set in the admin. So, I'm not sure. Are these independent configs that need to be made to match manually? Or is the jrun.xml file supposed to be written by the CF Admin when changes are made there? Hmm. But maybe this is different because presumably the CF Scheduler should only use a subset of all available threads, right...so we'd always have some threads for real live users. We also have this in there:
<service class="jrun.servlet.http.WebService" name="WebService">
<attribute name="port">8500</attribute>
<attribute name="interface">*</attribute>
<attribute name="deactivated">true</attribute>
<attribute name="activeHandlerThreads">200</attribute>
<attribute name="minHandlerThreads">1</attribute>
<attribute name="maxHandlerThreads">1000</attribute>
<attribute name="mapCheck">0</attribute>
<attribute name="threadWaitTimeout">300</attribute>
<attribute name="backlog">500</attribute>
<attribute name="timeout">300</attribute>
</service>
This appears to have changed when I changed the CF Admin setting...maybe...but it's the activeHandlerThreads that matches my new maximum simulataneous requests setting...rather than the maxHandlerThreads, which again exceeds it. Finally, we have this:
<service class="jrun.servlet.jrpp.JRunProxyService" name="ProxyService">
<attribute name="activeHandlerThreads">200</attribute>
<attribute name="minHandlerThreads">1</attribute>
<attribute name="maxHandlerThreads">1000</attribute>
<attribute name="mapCheck">0</attribute>
<attribute name="threadWaitTimeout">300</attribute>
<attribute name="backlog">500</attribute>
<attribute name="deactivated">false</attribute>
<attribute name="interface">*</attribute>
<attribute name="port">51800</attribute>
<attribute name="timeout">300</attribute>
<attribute name="cacheRealPath">true</attribute>
</service>
So, I'm not certain which (if any) of these I should change and what exactly the relationship is between maximum requests and maximum threads. Also, since several of these list the maxHandlerThreads as 1000, I'm wondering if I should just set the maximum simultaneous requests to 1000. There must be some upper limit that depends on available server resources...but I'm not sure what it is and I don't really want to play around with it since it's a production environment.
I'm not sure if it pertains to this issue at all, but when I run a ps aux | grep coldfusion I get the following:
wwwrun   15853 0.0 0.0   8704   760 pts/1
S
20:22   0:00 /opt/coldfusion9/runtime/bin/coldfusion9 -jar jrun.jar -autorestart -start coldfusion
wwwrun   15855 5.4 18.2 1678552 701932 pts/1
Sl
20:22   1:38 /opt/coldfusion9/runtime/bin/coldfusion9 -jar jrun.jar -start coldfusion
There are always these two and never more than these two processes. So there does not appear to be a one-to-one relationship between processes and threads. I recall from an MX 6.1 install I maintained for many years that additional CF processes were visible in the process list. It seemed to me at the time like I had a process for each thread...so either I was wrong or something is quite different in version 9 since it's reporting 25 running requests and only showing these two processes. If a single process can have multiple threads in the background, then I'm given to wonder why I have two processes instead of one...just curious.
So, anyway, I've been experimenting while composing this post. As noted above I adjusted the maximum simulataneous requests up to 200. I was hoping this would solve my problem, but CF just crashed again (rather it slogged down and requests started timing out...so effectively "crashed"). This time, top looked similar (still consuming more than 99% of the CPU), but CF status looked different:
Pg/Sec DB/Sec CP/Sec Reqs Reqs Reqs AvgQ   AvgReq AvgDB Bytes Bytes
Now Hi Now Hi Now Hi Q'ed Run'g TO'ed Time   Time   Time   In/Sec Out/Sec
0   0   0   0   -1 -1 0     150   0     0      0      0      0      0
Obviously, since I'd increased the maximum simultaneous requests, it was allowing more requests to run simultaneously...but it was still maxing out the server resources.
Further experiments (after restarting CF) showed me that the server became unusably slogged after about 30-35 "Reqs Run'g", with all additional requests headed for an inevitible timeout:
Pg/Sec DB/Sec CP/Sec Reqs Reqs Reqs AvgQ   AvgReq AvgDB Bytes Bytes
Now Hi Now Hi Now Hi Q'ed Run'g TO'ed Time   Time   Time   In/Sec Out/Sec
0   0   0   0   -1 -1 0     33    0     0      -492   0      0      0
So, it's clear that increasing the maximum simultaneous requests has not helped. I guess what it comes down to is this: What is it having such a hard time with? Where are these spikes coming from? Bursts of traffic? On what pages? What requests are running at any given time? I guess I simply need more information to continue troubleshooting. If there are long-running requests, or other issues, I'm not seeing it in the logs (although I do have that option checked in the admin). I need to know which requests exactly are those responsible for these spikes. Any help would be much appreciated. Thanks.
~Day

I really appreciate your help. However, I haven't been able to find the JRun Thread settings you describe above.
Under Request Tuning, I see:
Server Settings > Request Tuning
Request Limits
Maximum number of simultaneous Template requests
Restricts the number of simultaneously processed requests. Use this setting to increase overall system performance for heavy load applications. Requests beyond the specified limit are queued. On Standard Edition, you must restart ColdFusion to enable this setting.
Maximum number of simultaneous Flash Remoting requests
The number of Flash Remoting requests that can be processed concurrently.
Maximum number of simultaneous Web Service requests
The number of Web Service requests that can be processed concurrently.
Maximum number of simultaneous CFC function requests
The number of ColdFusion Component methods that can be processed concurrently via HTTP. This does not affect invocation of CFC methods from within CFML, only methods requested via an HTTP request.
Tag Limit Settings
Maximum number of simultaneous Report threads
The maximum number of ColdFusion reports that can be processed concurrently.
Maximum number of threads available for CFTHREAD
The maximum number of threads created by CFTHREAD that will be run concurrently. Threads created by CFTHREAD in excess of this are queued. On Standard Edition, the maximum limit is 10.
And under Java and JVM, I see:
Server Settings > Java and JVM
    Java and JVM settings control the way ColdFusion starts the Java Virtual Machine when it starts. You can control settings like what classpaths are used and how memory is allocated as well as add custom command line arguments. Changing these settings requires restarting ColdFusion. If you enter an incorrect setting, ColdFusion may not restart properly.
   Backups of the jvm.config file are created when you hit the submit button. You can use this backup to restore from a critical change.
   Java Virtual Machine Path
Specifies the location of the Java Virtual Machine.
   Minimum JVM Heap Size (MB)         Maximum JVM Heap Size (MB)
   The Memory Size settings determine the amount of memory that the JVM can use for programs and data.
   ColdFusion Class Path
Specifies any additional class paths for the JVM, with multiple directories separated by commas.
   JVM Arguments
-server -Dsun.io.useCanonCaches=false -XX:MaxPermSize=192m -XX:+UseParallelGC -Xbatch -Dcoldfusion.rootDir={application.home}/../ -Dcoldfusion.libPath={application.home}/../lib
Specifies any specific JVM initialization options, separated by spaces.
I did go take a look at FusionReactor and found it's not free (which would be fine, of course, if it would actually help). It looks like there's a fully functional demo, which is cool...but I've haven't been able to get it to install yet, so we'll see.
Thanks again!
~Day
(By the way, I've cross-posted this inquiry on StackOverflow. So if you're able to help me arrive at a solution you might want to answer there as well.)

Custom thread pool for Java 8 parallel stream

It seems that it is not possible to specify thread pool for Java 8 parallel stream. If that's so, the whole functionality is useless in most of the situations. The only situation I can safely use it is a small single threaded application written by one person.
In all other cases, if I can not specify the thread pool, I have to share the default pool with other parts of the application. If someone submits a task that takes a lot of time, my tasks will get stuck. Is that correct or am I overlooking something?
Imagine that someone submits slow networking operation to the fork-join pool. It's not a good idea, but it's so tempting that it will be happening. In such case, all CPU intensive tasks executed on parallel streams will wait for the networking task to finish. There is nothing you can do to defend your part of the application against such situations. Is that so?

You are absolutely correct. That isn't the only problem with using the F/J framework as the parallel engine for bulk operations. Have a look http://coopsoft.com/ar/Calamity2Article.html

Thread pool rejecting threads when I don't think it should, ideas?

Hi,
I have a server application in which I only want a specific number of simultaneous requests. If the server gets more then this number it is suppose to close the connection (sends an HTTP 503 error to the client). To do this I used a fix thread pool. When I start the server and submit the max number of requests I get the expected behavior. However if I resubmit the request (within a small period of time, e.g. 1-15 seconds after the first one) I get very odd behavior in that some of the requests are rejected. For example if I set the max to 100 the first set of requests will work fine (100 requests, 100 responses). I then submit again and a small number will be rejected (I've seen it range from 1 to 15 rejected)....
I made a small app which kind of duplicates this behavior (see below). Basically when I see is that the first time submitting requests works fine but the second time I get a rejected one. As best as I can tell none should be rejected....
Here is the code, I welcome your thoughts or if you see something I am doing wrong here...
<pre>
import java.util.concurrent.*;
import java.util.concurrent.atomic.AtomicInteger;
public class ThreadPoolTest {
     static AtomicInteger count = new AtomicInteger();
     public static class threaded implements Runnable {
          @Override
          public void run() {
               System.out.println("In thread: " + Thread.currentThread().getId());
               try {
                    Thread.sleep(500);
               } catch (InterruptedException e) {
                    System.out.println("Thread: " + Thread.currentThread().getId()
                              + " interuptted");
               System.out.println("Exiting run: " + Thread.currentThread().getId());
     private static int maxThreads = 3;
     private ThreadPoolExecutor pool;
     public ThreadPoolTest() {
          super();
          pool = new java.util.concurrent.ThreadPoolExecutor(
                    1, maxThreads - 1, 60L, TimeUnit.SECONDS,
                    new ArrayBlockingQueue<Runnable>(1));
     public static void main(String[] args) throws InterruptedException {
          ThreadPoolTest object = new ThreadPoolTest();
          object.doThreads();
          Thread.sleep(3000);
          object.doThreads();
          object.pool.shutdown();
          try {
               object.pool.awaitTermination(60, TimeUnit.SECONDS);
          } catch (InterruptedException e) {
               // TODO Auto-generated catch block
               e.printStackTrace();
     private void doThreads() {
          int submitted = 0, rejected = 0;
          int counter = count.getAndIncrement();
          for (int x = 0; x < maxThreads ; x++) {
               try {
                    System.out.println("Run #: " + counter + " submitting " + x);
                    pool.execute(new threaded());
                    submitted++;
               catch (RejectedExecutionException re) {
                    System.err.println("\tRun #: " + counter + ", submission " + x
                              + " was rejected");
                    System.err.println("\tQueue active: " + pool.getActiveCount());
                    System.err.println("\tQueue size: " + pool.getPoolSize());
                    rejected++;
          System.out.println("\n\n\tRun #: " + counter);
          System.out.println("\tSubmitted: " + (submitted + rejected));
          System.out.println("\tAccepted: " + submitted);
          System.out.println("\tRejected: " + rejected + "\n\n");
</pre>

First thank you for taking the time to reply, I do appreciate it.
jtahlborn - The code provided here is a contrived example trying to emulate the bigger app as best as I could. The actual program doesn't have any sleeps, the sleep in the secondary thread is to simulate the program doing some work & replying to a request. The sleep in the primary thread is to simulate a small delay between 'requests' to the pool. I can make this 1 second and up to (at least) 5 seconds with the same results. Additionally I can take out the sleep in the secondary thread and still see the a rejection.
EJP - Yes I am aware of the TCP/IP queue, however; I don't see that as relevant to my question. The idea is not to prevent the connection but to respond to the client saying we can't process the request (send an "HTTP 503" error). So basically if we have, say, 100 threads running then the 101st, connection will get a 503 error and the connection will be closed.
Also my test platform - Windows 7 64bit running Java 1.6.0_24-b07 (32bit) on an Intel core i7.
It occurred to me that I did not show the output of the test program. As the output shows below, the first set of requests are all processed properly. The second set of requests is not. The pool should have 2 threads and 1 slot in the queue, so by the time the second "request" is made at least 2 of the requests from the first call should be done processing, so I could possibly understand run 1, submit #2 failing but not submit 1.
<pre>
Run #: 0 submitting 0
Run #: 0 submitting 1
Run #: 0 submitting 2
In thread: 8
In thread: 9
Exiting run: 8
Exiting run: 9
     Run #: 0
     Submitted: 3
     Accepted: 3
     Rejected: 0
In thread: 8
Exiting run: 8
Run #: 1 submitting 0
In thread: 9
Run #: 1 submitting 1
     Run #: 1, submission 1 was rejected
     Queue active: 1
     Queue size: 2
Run #: 1 submitting 2
     Run #: 1
     Submitted: 3
     Accepted: 2
     Rejected: 1
In thread: 8
Exiting run: 9
Exiting run: 8
</pre>

Thread Pool , Executors ...

Sorry if i make a stupid post now, but i'm looking for a implementation of a Thread Pool using the latest 1.5 java.util.concurrent classes and i can't find anything serious. Any implementation or link to a tutorial should be vary helpful.
Thnx

but i'm looking
for a implementation of a Thread Pool using
the latest 1.5 java.util.concurrent classes and i
can't find anything serious. Any implementation or
link to a tutorial should be vary helpful.
Thnxhere is an Example :
import java.util.concurrent.*;
public class UtilConcurrentTest {
public static void main(String[] args) throws InterruptedException {
int numThreads = 4;
int numTasks = 20;
ExecutorService service = Executors.newFixedThreadPool(numThreads);
// do some tasks:
for (int i = 0; i < numTasks; i++) {
service.execute(new Task(i));
service.shutdown();
log("called shutdown()");
boolean isTerminated = service.awaitTermination(60, TimeUnit.SECONDS);
log("service terminated: " + isTerminated);
public static void log(String msg) {
System.out.println(System.currentTimeMillis() + "\t" + msg);
private static class Task implements Runnable {
private final int id;
public Task(int id) {
this.id = id;
public void run() {
log("begin:\t" + this);
try { Thread.sleep(1000); } catch (InterruptedException e) {}
log("end\t" + this);
public String toString() {
return "Task " + id + " in thread " + Thread.currentThread().getName();
}

Thread pool executor problem

When using a thread pool executor (java.util.concurrent.ThreadPoolExecutor) to limit the number of threads executing at a time, the number of threads running still exceeds the limit number.
This is the code:
private ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(2, 3, 20, TimeUnit.SECONDS, new LinkedBlockingQueue());
The number of tasks in my program are 4, so i always have 4 threads running, although i limited it to 3.
Can anyone help me with this problem? Or can u propose another solution to limit the number of running threads? By the way, i also tried using a newFixedThreadPool() and got the same problem.
Thx.

The number of tasks in my program are 4, so i always
have 4 threads running, although i limited it to 3.How do you know that there are 4 threads running? If you're generating a JVM thread dump, you're going to see threads that are used internally by the JVM.
Here's a simple program that creates a fixed-size threadpool and runs jobs. It limits the number of concurrent threads to 3. Compare it to what you're doing, I'm sure that you'll find something different. Also, verify that you're not creating threads somewhere else in your program; all of the ThreadPoolExecutor threads will have names of the form "pool-X-thread-Y"
import java.util.concurrent.Executors;
import java.util.concurrent.ExecutorService;
public class ThreadPoolTest {
    public static void main(String[] args) {
        ExecutorService pool = Executors.newFixedThreadPool(3);
        for (int ii = 0 ; ii < 10 ; ii++) {
            pool.execute(new MyRunnable());
        pool.shutdown();
    private static class MyRunnable implements Runnable {
        public void run() {
            log("running");
            try {
                Thread.sleep(1000L);
            catch (InterruptedException e) {
                log("interrupted");
        private void log(String msg) {
            System.err.println(
                    msg + " on " + Thread.currentThread().getName()
                    + " at " + System.currentTimeMillis());
}

Thread pool in servlet container

Hello all,
I'm working on this webapp that has some bad response times and I've identified an area were we could shave off a considerable amount of time. The app is invoking a component that causes data to be catched for subsequently targeted apps in the environemnt. Our app does not need to wait for a response so I'd like to make this an asyncronous call. So, how best to implement this?...I considered JMS, but started working on a solution using the Java 1.4 backport of JSR 166 (java.util.concurrent).
I've been testing the use of a ThreadPoolExecutor, using an ArrayBlockingQueue. The work that each Runnable will perform involves a lot of waiting (the component we call invokes a web service, among a couple other distributed calls). So I figure the pool will be much larger than the queue. Our container has 35 execute threads, so I've been testing with a thread pool size of 25, and a queue of 10.
Any thoughts on this approach? I understand that some of this work could be simplified by JMS, but if I don't need to be tied to the container, I'd prefer not to. The code if much easier to unit test, and plays nicely with our continious build integration (which runs our junit test for us and notifies on errors).
Any thoughts are greatly appreciated...Thanks!!

Well, if it works, that's by far the best way to go - but note that creating threads in a servlet container means those threads are outside of the container's control. Many containers will refuse to give the new threads access to the JNDI context, even, and some may prevent you from creating threads at all.

Thread pool throws reject exceptions even though the queue is not full

Hi. I am using org.springframework.scheduling.concurrent.ThreadPo olTaskExecutor which is based on java
java.util.concurrent.ThreadPoolExecutor
with a enviornment under load.
I see on some cases, that this thread pool throws tasks with reject exception
even though the queue size is 0.
According to the documentation, this thread pool should increase the pool size to core size and then wait untill all queue is full to create new threads.
this is not what happends. for some reason the queue is not filled but exceptions are thrown.
Any ideas why this can happen?

This is the stack trace:
taskExecutorStats-1 2010-04-27 11:01:43,324 ERROR [com.expand.expandview.infrastructure.task_executor] TaskExecutorController: RejectedExecutionException exception in thread: 18790970, failed on thread pool: [email protected]544f07, to run logic: com.expand.expandview.infrastructure.logics.DispatchLogicsProviderLogic
org.springframework.core.task.TaskRejectedException: Executor [java.util.concurrent.ThreadPoolExecutor@dd9007] did not accept task: com.expand.expandview.infrastructure.task_executor.TaskExecuterController$1@141f728; nested exception is java.util.concurrent.RejectedExecutionException
     at org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor.execute(ThreadPoolTaskExecutor.java:305)
     at com.expand.expandview.infrastructure.task_executor.TaskExecuterController.operate(TaskExecuterController.java:68)
     at com.expand.expandview.infrastructure.proxies.DataProxy.callLogic(DataProxy.java:131)
     at com.expand.expandview.infrastructure.proxies.DataProxy.operate(DataProxy.java:109)
     at com.expand.expandview.infrastructure.logics.AbstractLogic.operate(AbstractLogic.java:455)
     at com.expand.expandview.server.app.logics.stats.StatsPersisterSingleChunkLogic.persistSlots(StatsPersisterSingleChunkLogic.java:362)
     at com.expand.expandview.server.app.logics.stats.StatsPersisterSingleChunkLogic.doLogic(StatsPersisterSingleChunkLogic.java:132)
     at com.expand.expandview.infrastructure.logics.AbstractLogic.execute(AbstractLogic.java:98)
     at com.expand.expandview.server.app.logics.ApplicationLogic.execute(ApplicationLogic.java:79)
     at com.expand.expandview.infrastructure.task_executor.TaskExecuterControllerDirect.operate(TaskExecuterControllerDirect.java:33)
     at com.expand.expandview.infrastructure.proxies.LogicProxy.service(LogicProxy.java:62)
     at com.expand.expandview.infrastructure.logics.AbstractLogic.service(AbstractLogic.java:477)
     at com.expand.expandview.server.app.logics.stats.StatsPersisterLogic.persist(StatsPersisterLogic.java:48)
     at com.expand.expandview.server.app.logics.stats.StatsPersisterLogic.doLogic(StatsPersisterLogic.java:19)
     at com.expand.expandview.infrastructure.logics.AbstractLogic.execute(AbstractLogic.java:98)
     at com.expand.expandview.server.app.logics.ApplicationLogic.execute(ApplicationLogic.java:79)
     at com.expand.expandview.infrastructure.task_executor.TaskExecuterController$1.run(TaskExecuterController.java:80)
     at java.util.concurrent.ThreadPoolExecutor$Worker.runTask(ThreadPoolExecutor.java:886)
     at java.util.concurrent.ThreadPoolExecutor$Worker.run(ThreadPoolExecutor.java:908)
     at java.lang.Thread.run(Thread.java:619)
Caused by: java.util.concurrent.RejectedExecutionException
     at java.util.concurrent.ThreadPoolExecutor$AbortPolicy.rejectedExecution(ThreadPoolExecutor.java:1760)
     at java.util.concurrent.ThreadPoolExecutor.reject(ThreadPoolExecutor.java:767)
     at java.util.concurrent.ThreadPoolExecutor.execute(ThreadPoolExecutor.java:658)
     at org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor.execute(ThreadPoolTaskExecutor.java:302)
     ... 19 more

Thread Pool Callback Mechanism

I am using java.util.concurrent.ExecutorService to create a thread pool. I need a way to inform the user of the progress of the threads in the pool.
Does anyone have any ideas of how to do this?

I am using java.util.concurrent.ExecutorService to
create a thread pool. I need a way to inform the user
of the progress of the threads in the pool.
Does anyone have any ideas of how to do this?Hand the Executor instances of SwingWorker, which implements RunnableFuture. SwingWorker also has a progress() method which can provide progress information.

Using AsyncEventHandlers as a RTJ buildin thread pool

Similar Messages

Maybe you are looking for