How to avoid multithreded program being blocked due to threads are waiting

Question

I have a module which operates on thousands of transactions to process . Each transaction has multiple phases to go through. This module executes in multithreaded mode. We have defined limits (hardcoded)for number of threads it can create (limited as per server utilization ).

now we came accross a situation, where threads may need to wait for some period (may be more than 24 hours). As we have limited number of threads and if all threads are waiting for more than 24 hours, this is entirely blocking the application.

What i need here is, how should i reuse the thread which is under wait wait for 24 hour. if thread is going in wait mode, i need to reuse that thread for anather transaction and when original wait ends, restart the original transaction from where it was put on hold.

i hope above discription helps u to understand issue.

Answer 1

If you have long delays in your system, the best thing to do is to have more threads. If you want to limit the number of threads running concurrently you can use permits e.g. a Semaphore which is released whenever you have blocking operation and re-acquired when the blocking finishes. This ensures you have a limited number of threads running at once but allows you to easily switch between many tasks.

public abstract class LimitedTask implements Runnable {
    static final Semaphore PERMITS = new Semaphore(Runtime.getRuntime().availableProcessors());

    @Override
    public final void run() {
        try {
            PERMITS.acquire();
        } catch (InterruptedException e) {
            System.err.println("Task " + getClass() + " cancelled before it was started.");
            return;
        }
        try {
            runTask();
        } finally {
            PERMITS.release();
        }
    }

    protected abstract void runTask();

    protected void runBlockingTask(Runnable runnable) {
        PERMITS.release();
        try {
            runnable.run();
        } finally {
            PERMITS.acquireUninterruptibly();
        }
    }
}

In this example, you can have as many of these as you want but only a limited number will be within the PERMIT area. The tasks can also call runBlockingTask() to allow it to perform a blocking task but allow another thread to run while it is blocking.