預初始化工作線程池以重用連接對象（套接字）

Question

我需要在Java中構建一個工作者池，其中每個工作者都有自己的連接套接字;當工作線程運行時，它使用套接字，但保持打開狀態以便稍後重用。我們決定採用這種方法，因爲與臨時創建，連接和銷燬套接字相關的開銷需要太多的開銷，所以我們需要一種方法，通過這種方法，一組工作者通過套接字連接進行預初始化，隨時準備承擔的工作，同時保持插座資源從其它線程（插座不是線程安全的）安全，所以我們需要沿着這些路線的東西...

public class SocketTask implements Runnable { 
    Socket socket; 
    public SocketTask(){ 
    //create + connect socket here 
    } 

    public void run(){ 
    //use socket here 
    } 

}

在應用程序啓動時，我們要初始化工作人員以及希望的插座連接太...

MyWorkerPool pool = new MyWorkerPool(); 
for(int i = 0; i < 100; i++) 
    pool.addWorker(new WorkerThread()); 

隨着工作由應用程序的要求，我們派任務給工人池立即執行......

pool.queueWork(new SocketTask(..)); 

更新的工作代碼
基於從灰色和jontejj有益的意見，我有下面的代碼工作...

SocketTask

public class SocketTask implements Runnable { 
    private String workDetails; 
    private static final ThreadLocal<Socket> threadLocal = 
      new ThreadLocal<Socket>(){ 
     @Override 
     protected Socket initialValue(){ 
      return new Socket(); 
     }   
    }; 

    public SocketTask(String details){    
     this.workDetails = details; 
    } 

    public void run(){  
     Socket s = getSocket(); //gets from threadlocal 
     //send data on socket based on workDetails, etc. 
    } 

    public static Socket getSocket(){ 
     return threadLocal.get(); 
    } 
} 

個

的ExecutorService

ExecutorService threadPool = 
    Executors.newFixedThreadPool(5, Executors.defaultThreadFactory()); 

    int tasks = 15; 
    for(int i = 1; i <= tasks; i++){ 
     threadPool.execute(new SocketTask("foobar-" + i)); 
    } 

我喜歡這種方法有以下幾個原因...

• 套接字是本地對象（通過ThreadLocal的）提供給正在運行的任務，消除了併發問題。
• 套接字創建一次並保持打開狀態，當新任務排隊時重複使用 ，消除套接字對象創建/銷燬開銷。

Answer 1

想法之一是將Socket s放入BlockingQueue。然後，無論何時您需要Socket您的線程可以從隊列take()，當他們完成Socket他們put()它回到隊列中。

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

這有額外的好處：

• 你可以回去使用ExecutorService代碼。
• 您可以將套接字通信與處理結果分開。
• 您不需要1對1的對應關係來處理線程和套接字。但套接字通信可能是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 ... 
    } 
} 

Answer 2

我想如果每個線程都有自己的插座應使用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... 
    } 
} 

。