具有n个线程和n个相应对象的ExecutorService

Question

I have service that use fixed thread pool because more then 10 instances of this heavy task will be too much for my server.

ExecutorService newFixedThreadPool = Executors.newFixedThreadPool(10);

I use it something like:

Runnable command = new Runnable() {
        @Override
        public void run() {
            MyHeavyClassWithCache myHeavyClassWithCache=new MyHeavyClassWithCache();
        }
    };
    Future<ScreenImage> feature = executor.submit(command,myHeavyClassWithCacheResult);

Now I need to have also only n (10) instances of MyHeavyClassWithCache class. And also need to reuse it somehow in executor (much faster then to create it like I do now). How can I manage this kind of thing with ExecutorService. Goal is to achieve that max 10 threads working at the same time by using one of my 10 instances of MyHeavyClassWithCache class (never two threads with same instances at same time!)

I hope this is common enough to exists some java design pattern to achieve this.

Answer 1

Goal is to achieve that max 10 threads working at the same time by using one of my 10 instances of MyHeavyClassWithCache class

There are a couple of ways to do this. The easiest way may be to use a ThreadLocal<MyHeavyClassWithCache> so that each of the pool threads gets their own "heavy" class. Your Runnable instances would define the ThreadLocal .

The alternative would be to submit 10 HeavyRunnable instances to your pool, each with their own local instance of MyHeavyClassWithCache and have those dequeue from a different BlockingQueue . This is a pattern that I've used before.

The code might look something like:

// runnable that dequeues from a blocking queue and keeps a heavy instance
private static class HeavyRunnable implements Runnable {
    private final MyHeavyClassWithCache heavy = new MyHeavyClassWithCache();
    private final BlockingQueue<Runnable> runnableQueue;
    public HeavyRunnable(BlockingQueue<Runnable> runnableQueue) {
        this.runnableQueue = runnableQueue;
    }
    public void run() {
        while (!Thread.currentThread.isInterrupted()) {
             Runnable runnable = runnableQueue.take();
             // if we see a null then stop running
             if (runnable == null) {
                 break;
             }
             runnable.run();
        }
    }
}

...
final ExecutorService newFixedThreadPool = Executors.newFixedThreadPool(10);
final BlockingQueue<Runnable> runnableQueue = new LinkedBlockingQueue<>();
newFixedThreadPool.add(new HeavyRunnable(runnableQueue));
...
runnableQueue.add(new Runnable() { ... });
...

It's a bit of a challenge to shutdown these background heavy runnables but putting 10 null s in the queue and having the threads shutdown when they dequeue null is one way.