Предварительная инициализация пула рабочих потоков для повторного использования объектов подключения (сокетов)

Одна из идей - поместить Socket в BlockingQueue. Затем, когда вам понадобится Socket, ваши потоки могут take() выйти из очереди, а когда они завершат работу с Socket, они put() вернутся в очередь.

public void run() {
    Socket socket = socketQueue.take();
    try {
       // use the socket ...
    } finally {
       socketQueue.put(socket);
    }
}

Это дает дополнительные преимущества:

• Вы можете вернуться к использованию кода ExecutorService.
• Вы можете отделить обмен данными через сокет от обработки результатов.
• Вам не нужно соответствие один-к-одному для обработки потоков и сокетов. Но связь через сокеты может составлять 98% работы, так что, возможно, никакой выгоды.
• Когда вы закончите и ваш ExecutorService завершится, вы можете выключить свои сокеты, просто исключив их из очереди и закрыв.

Это добавляет дополнительные накладные расходы на другой BlockingQueue, но если вы делаете Socket общение, вы этого не заметите.

мы не верим, что ThreadFactory удовлетворяет наши потребности ...

Я думаю, вы могли бы это сделать, если бы использовали локальные потоки. Ваша фабрика потоков создаст поток, который сначала открывает сокет, сохраняет его в локальном потоке, а затем вызывает Runnable arg, который выполняет всю работу с сокетом, удаляя задания из внутренней очереди ExecutorService. Как только это будет сделано, метод arg.run() завершится, и вы сможете получить сокет из локального потока и закрыть его.

Примерно так. Это немного беспорядочно, но вы должны уловить идею.

ExecutorService threadPool =
    Executors.newFixedThreadPool(10,
      new ThreadFactory() {
        public Thread newThread(final Runnable r) {
            Thread thread = new Thread(new Runnable() {
                public void run() {
                    openSocketAndStoreInThreadLocal();
                    // our tasks would then get the socket from the thread-local
                    r.run();
                    getSocketFromThreadLocalAndCloseIt();
                }
            });
            return thread;
        }
      }));

Итак, ваши задачи будут реализованы Runnable и будут выглядеть так:

public SocketWorker implements Runnable {
    private final ThreadLocal<Socket> threadLocal;
    public SocketWorker(ThreadLocal<Socket> threadLocal) {
       this.threadLocal = threadLocal;
    }
    public void run() {
        Socket socket = threadLocal.get();
        // use the socket ...
    }
}

Я думаю, вам следует использовать ThreadLocal

package com.stackoverflow.q16680096;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class Main
{
    public static void main(String[] args)
    {
        ExecutorService pool = Executors.newCachedThreadPool();
        int nrOfConcurrentUsers = 100;
        for(int i = 0; i < nrOfConcurrentUsers; i++)
        {
            pool.submit(new InitSocketTask());
        }

        // do stuff...

        pool.submit(new Task());
    }
}

package com.stackoverflow.q16680096;

import java.net.Socket;

public class InitSocketTask implements Runnable
{
    public void run()
    {
        Socket socket = SocketPool.get();
        // Do initial setup here
    }

}

package com.stackoverflow.q16680096;

import java.net.Socket;

public final class SocketPool
{
    private static final ThreadLocal<Socket> SOCKETS = new ThreadLocal<Socket>(){
        @Override
        protected Socket initialValue()
        {
            return new Socket(); // Pass in suitable arguments here...
        }
    };

    public static Socket get()
    {
        return SOCKETS.get();
    }
}

package com.stackoverflow.q16680096;

import java.net.Socket;

public class Task implements Runnable
{
    public void run()
    {
        Socket socket = SocketPool.get();
        // Do stuff with socket...
    }
}

Где каждый поток получает свой сокет.