Java Socket編程實例（三）- TCP辦事端線程池。本站提示廣大學習愛好者：（Java Socket編程實例（三）- TCP辦事端線程池）文章只能為提供參考，不一定能成為您想要的結果。以下是Java Socket編程實例（三）- TCP辦事端線程池正文
1、辦事端回傳辦事類：
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.Socket;
import java.util.logging.Level;
import java.util.logging.Logger;
public class EchoProtocol implements Runnable {
private static final int BUFSIZE = 32; // Size (in bytes) of I/O buffer
private Socket clientSocket; // Socket connect to client
private Logger logger; // Server logger
public EchoProtocol(Socket clientSocket, Logger logger) {
this.clientSocket = clientSocket;
this.logger = logger;
}
public static void handleEchoClient(Socket clientSocket, Logger logger) {
try {
// Get the input and output I/O streams from socket
InputStream in = clientSocket.getInputStream();
OutputStream out = clientSocket.getOutputStream();
int recvMsgSize; // Size of received message
int totalBytesEchoed = 0; // Bytes received from client
byte[] echoBuffer = new byte[BUFSIZE]; // Receive Buffer
// Receive until client closes connection, indicated by -1
while ((recvMsgSize = in.read(echoBuffer)) != -1) {
out.write(echoBuffer, 0, recvMsgSize);
totalBytesEchoed += recvMsgSize;
}
logger.info("Client " + clientSocket.getRemoteSocketAddress() + ", echoed " + totalBytesEchoed + " bytes.");
} catch (IOException ex) {
logger.log(Level.WARNING, "Exception in echo protocol", ex);
} finally {
try {
clientSocket.close();
} catch (IOException e) {
}
}
}
public void run() {
handleEchoClient(this.clientSocket, this.logger);
}
}
2、每一個客戶端要求都新啟一個線程的Tcp辦事端：
import java.io.IOException;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.logging.Logger;
public class TCPEchoServerThread {
public static void main(String[] args) throws IOException {
// Create a server socket to accept client connection requests
ServerSocket servSock = new ServerSocket(5500);
Logger logger = Logger.getLogger("practical");
// Run forever, accepting and spawning a thread for each connection
while (true) {
Socket clntSock = servSock.accept(); // Block waiting for connection
// Spawn thread to handle new connection
Thread thread = new Thread(new EchoProtocol(clntSock, logger));
thread.start();
logger.info("Created and started Thread " + thread.getName());
}
/* NOT REACHED */
}
}
3、固定線程數的Tcp辦事端：
import java.io.IOException;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.logging.Level;
import java.util.logging.Logger;
public class TCPEchoServerPool {
public static void main(String[] args) throws IOException {
int threadPoolSize = 3; // Fixed ThreadPoolSize
final ServerSocket servSock = new ServerSocket(5500);
final Logger logger = Logger.getLogger("practical");
// Spawn a fixed number of threads to service clients
for (int i = 0; i < threadPoolSize; i++) {
Thread thread = new Thread() {
public void run() {
while (true) {
try {
Socket clntSock = servSock.accept(); // Wait for a connection
EchoProtocol.handleEchoClient(clntSock, logger); // Handle it
} catch (IOException ex) {
logger.log(Level.WARNING, "Client accept failed", ex);
}
}
}
};
thread.start();
logger.info("Created and started Thread = " + thread.getName());
}
}
}
4、應用線程池(應用Spring的線程次會有隊列、最年夜線程數、最小線程數和超不時間的概念)
1.線程池對象類：
import java.util.concurrent.*;
/**
* 義務履行者
*
* @author Watson Xu
* @since 1.0.0 <p>2013-6-8 上午10:33:09</p>
*/
public class ThreadPoolTaskExecutor {
private ThreadPoolTaskExecutor() {
}
private static ExecutorService executor = Executors.newCachedThreadPool(new ThreadFactory() {
int count;
/* 履行器會在須要自行義務而線程池中沒有線程的時刻來挪用該法式。關於callable類型的挪用經由過程封裝今後轉化為runnable */
public Thread newThread(Runnable r) {
count++;
Thread invokeThread = new Thread(r);
invokeThread.setName("Courser Thread-" + count);
invokeThread.setDaemon(false);// //????????????
return invokeThread;
}
});
public static void invoke(Runnable task, TimeUnit unit, long timeout) throws TimeoutException, RuntimeException {
invoke(task, null, unit, timeout);
}
public static <T> T invoke(Runnable task, T result, TimeUnit unit, long timeout) throws TimeoutException,
RuntimeException {
Future<T> future = executor.submit(task, result);
T t = null;
try {
t = future.get(timeout, unit);
} catch (TimeoutException e) {
throw new TimeoutException("Thread invoke timeout ...");
} catch (Exception e) {
throw new RuntimeException(e);
}
return t;
}
public static <T> T invoke(Callable<T> task, TimeUnit unit, long timeout) throws TimeoutException, RuntimeException {
// 這裡將義務提交給履行器，義務曾經啟動，這裡是異步的。
Future<T> future = executor.submit(task);
// System.out.println("Task aready in thread");
T t = null;
try {
/*
* 這裡的操作是確認義務能否曾經完成，有了這個操作今後
* 1)對invoke()的挪用線程釀成了期待義務完成狀況
* 2)主線程可以吸收子線程的處置成果
*/
t = future.get(timeout, unit);
} catch (TimeoutException e) {
throw new TimeoutException("Thread invoke timeout ...");
} catch (Exception e) {
throw new RuntimeException(e);
}
return t;
}
}
2.具有伸縮性的Tcp辦事端：
import java.io.IOException;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.concurrent.TimeUnit;
import java.util.logging.Logger;
import demo.callable.ThreadPoolTaskExecutor;
public class TCPEchoServerExecutor {
public static void main(String[] args) throws IOException {
// Create a server socket to accept client connection requests
ServerSocket servSock = new ServerSocket(5500);
Logger logger = Logger.getLogger("practical");
// Run forever, accepting and spawning threads to service each connection
while (true) {
Socket clntSock = servSock.accept(); // Block waiting for connection
//executorService.submit(new EchoProtocol(clntSock, logger));
try {
ThreadPoolTaskExecutor.invoke(new EchoProtocol(clntSock, logger), TimeUnit.SECONDS, 3);
} catch (Exception e) {
}
//service.execute(new TimelimitEchoProtocol(clntSock, logger));
}
/* NOT REACHED */
}
}
以上就是本文的全體內容，檢查更多Java的語法，年夜家可以存眷：《Thinking in Java 中文手冊》、《JDK 1.7 參考手冊官方英文版》、《JDK 1.6 API java 中文參考手冊》、《JDK 1.5 API java 中文參考手冊》，也願望年夜家多多支撐。
