Reuse a waiting/blocked thread

Question

Using the API in java.util.concurrency, there are operations such as BlockingQueue.take() or Condition.await() that makes the current thread to be blocked (waiting) on the operation to complete. I am working on a problem in which, in such situation, it is very costly to leave the thread as such holding all the resources already allocated for it. I would like to use the same thread to run/execute another task. And, when the condition or take can continue their work, then the resources are allocated back to the thread (including the local state) such that the thread can continue the execution from the blocked/waiting point. So, my question is that is there any way to release the thread when it is blocked on some concurrent operation such that it can be used for other executions?
On a related ground, is there any way I can replace the Thread class implementation in Java/JVM?
My current impression is that since some parts of the implementations are native so we need to tweak the C++ code, is that correct?
Thanks in advance.

Answer 1

i think you are missing the point of what i'm saying. i'm saying you don't need to change how threads work, you need to change your style of programming. having multiple tasks run on the same physical thread is as easy to do in java as it is in erlang (as Peter Lawrey described). what you need to do is use the erlang style of programming, where a thread does not block waiting for something to happen, but is instead giving a task when there is work today. i.e. you need to write your tasks so that they are essentially non-blocking. you can do this just fine in java without mucking w/ the jvm.
for instance, say you have a standard model with 3 queues, 3 producers, and 3 consumers, where there is 1 producer and 1 consumer per queue, and the consumer is a dedicated thread. in this scenario, if a queue is empty, that thread is idle/useless. instead, you can change your model around so that instead of each producer putting "data" on the queue, they instantiate a "handler/consumer" (instance of Runnable) with a reference to the data to be handled. this handler is then tossed into a thread pool with 3 threads. in this scenario, your 3 threads are now "general purpose" and can work on whichever queue(s) happen to currently have data. (in essence, you are collapsing your 3 queues into 1 queue and making the queue data "smarter"). this is exactly what erlang is doing under the hood.
Edited by: jtahlborn on Jul 28, 2011 11:34 AM