Socket 多线程演进与线程池使用

最新推荐文章于 2021-02-16 08:46:39 发布
最新推荐文章于 2021-02-16 08:46:39 发布
阅读量437 收藏 3
点赞数
分类专栏： Socket 文章标签： Java Socket Thread Executos
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/boonya/article/details/102734792
版权

目录

一个简单的线程示例

如何将Socket客户端连接植入线程？

通过初始化线程个数模拟一个线程池

使用Java Executor ExecutorService线程池管理Socket多线程

 一个简单的线程示例

实现一个线程可以继承Thread类或者实现Runnable接口：

package Chapter4;

import java.util.concurrent.TimeUnit;
/**
 * @TODO     (功能说明:线程例子)
 * @author   PJL
 * @package  Chapter4
 * @motto    学习需要毅力，那就秀毅力
 * @file     ThreadExample.java
 * @time     2019年10月24日 下午10:11:58
 */
public class ThreadExample implements Runnable {

	private String greeting; // Message to print to console

	public ThreadExample(String greeting) {
		this.greeting = greeting;
	}

	public void run() {
		while (true) {
			System.out.println(Thread.currentThread().getName() + ":  " + greeting);
			try {
				// Sleep 0 to 100 milliseconds
				TimeUnit.MILLISECONDS.sleep(((long) Math.random() * 100));
			} catch (InterruptedException e) {
			} // Should not happen
		}
	}

	public static void main(String[] args) {
		new Thread(new ThreadExample("Hello")).start();
		new Thread(new ThreadExample("Aloha")).start();
		new Thread(new ThreadExample("Ciao")).start();
	}
}

如何将Socket客户端连接植入线程？

当我们在服务端serverSocket.accept()接收到一个新的连接时，我们获取到的实际上是一个客户端连接的Socket实例。通过这个实例，我们可以实现数据的双向通信。将Socket作为参数放入线程，是为了让Socket流水作业变成线程式工作方式。

package Chapter4;

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;
/**
 * 
 * @TODO     (功能说明:Socket日志处理线程)
 * @author   PJL
 * @package  Chapter4
 * @motto    学习需要毅力，那就秀毅力
 * @file     EchoProtocol.java
 * @time     2019年10月24日 下午10:20:18
 */
public class EchoProtocol implements Runnable {
	private static final int BUFSIZE = 32; // Size (in bytes) of I/O buffer
	private Socket clntSock; // Socket connect to client
	private Logger logger; // Server logger

	public EchoProtocol(Socket clntSock, Logger logger) {
		this.clntSock = clntSock;
		this.logger = logger;
	}

	/**
	 * Socket处理日志方法
	 * @param clntSock
	 * @param logger
	 */
	public static void handleEchoClient(Socket clntSock, Logger logger) {
		try {
			// Get the input and output I/O streams from socket
			InputStream in = clntSock.getInputStream();
			OutputStream out = clntSock.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 " + clntSock.getRemoteSocketAddress() + ", echoed " + totalBytesEchoed + " bytes.");

		} catch (IOException ex) {
			logger.log(Level.WARNING, "Exception in echo protocol", ex);
		} finally {
			try {
				clntSock.close();
			} catch (IOException e) {
			}
		}
	}

	/**
	 * 线程执行方法
	 */
	public void run() {
		handleEchoClient(clntSock, logger);
	}
}

接下来就是将线程利用起来了，请看下面：

package Chapter4;

import java.io.IOException;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.logging.Logger;
/**
 * @TODO     (功能说明:一客户一线程方式处理Socket)
 * @author   PJL
 * @package  Chapter4
 * @motto    学习需要毅力，那就秀毅力
 * @file     TCPEchoServerThread.java
 * @time     2019年10月24日 下午10:29:46
 */
public class TCPEchoServerThread {

	public static void main(String[] args) throws IOException {
		
		if (args.length == 0) {
			args = new String[1];
			args[0] = "7402";
		}

		if (args.length != 1) { // Test for correct # of args
			throw new IllegalArgumentException("Parameter(s): <Port>");
		}

		int echoServPort = Integer.parseInt(args[0]); // Server port

		// Create a server socket to accept client connection requests
		ServerSocket servSock = new ServerSocket(echoServPort);

		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 */
	}
}

通过初始化线程个数模拟一个线程池

线程池的作用就是为了让线程能够被管理起来合理地使用，合理利用服务器资源。如果一个用户一个线程，那么我们的资源随着用户的增长而愈来愈紧张，所以为了避免线程的滥用，线程池的使用很重要。

package Chapter4;

import java.io.IOException;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.logging.Level;
import java.util.logging.Logger;
/**
 * @TODO     (功能说明:模拟线程池等待Socket请求处理)
 * @author   PJL
 * @package  Chapter4
 * @motto    学习需要毅力，那就秀毅力
 * @file     TCPEchoServerPool.java
 * @time     2019年10月24日 下午10:36:47
 */
public class TCPEchoServerPool {

	public static void main(String[] args) throws IOException {
		
		if (args.length == 0) {
			args = new String[2];
			args[0] = "7402";
			args[1] = "10";
		}

		if (args.length != 2) { // Test for correct # of args
			throw new IllegalArgumentException("Parameter(s): <Port> <Threads>");
		}

		int echoServPort = Integer.parseInt(args[0]); // Server port
		int threadPoolSize = Integer.parseInt(args[1]);

		// Create a server socket to accept client connection requests
		final ServerSocket servSock = new ServerSocket(echoServPort);

		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());
		}
	}
}

上面初始化了一定数量的线程，每个线程在没有收到请求时都是阻塞的，我们不知道哪一个线程会幸运地连接到新的请求，不确定性就是线程存在最有意思的地方。

使用Java Executor ExecutorService线程池管理Socket多线程

Executor 是线程池的基础接口类。

Executors 是线程池的一组实现方法，如下面：

我们可以这样来使用线程池对象：

int threadPoolSize=100;
Executor service0 =Executors.newFixedThreadPool(threadPoolSize);

Executor service1 = Executors.newCachedThreadPool();

ExecutorService service2=Executors.newCachedThreadPool();

Executor的方法很少：

ExecutorService提供了更为高级的方法：

下面来看一个Socket关于线程池的使用方式：

package Chapter4;

import java.io.IOException;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.concurrent.Executor;
import java.util.concurrent.Executors;
import java.util.logging.Logger;
/**
 * @TODO     (功能说明:Java自带高级线程池管理Socket请求线程服务)
 * @author   PJL
 * @package  Chapter4
 * @motto    学习需要毅力，那就秀毅力
 * @file     TCPEchoServerExecutor.java
 * @time     2019年10月24日 下午10:45:45
 */
public class TCPEchoServerExecutor {

	public static void main(String[] args) throws IOException {
		
		if (args.length == 0) {
			args = new String[1];
			args[0] = "7402";
		}

		if (args.length != 1) { // Test for correct # of args
			throw new IllegalArgumentException("Parameter(s): <Port>");
		}

		int echoServPort = Integer.parseInt(args[0]); // Server port

		// Create a server socket to accept client connection requests
		ServerSocket servSock = new ServerSocket(echoServPort);

		Logger logger = Logger.getLogger("practical");

		/*
		 * int threadPoolSize=100; 
		 * Executor service =Executors.newFixedThreadPool(threadPoolSize);
		 */
		Executor service = Executors.newCachedThreadPool(); // Dispatch svc

		// Run forever, accepting and spawning threads to service each connection
		while (true) {
			Socket clntSock = servSock.accept(); // Block waiting for connection
			service.execute(new EchoProtocol(clntSock, logger));
			// set timeout socket thread
			//service.execute(new TimelimitEchoProtocol(clntSock, logger));
		}
		/* NOT REACHED */
	}
}

另外Socket连接还比较关注阻塞问题，所以会涉及到超时问题的处理，主要是对Socket设置超时时间，如下例：

package Chapter4;

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;
/**
 * 
 * @TODO     (功能说明:时间限制-控制接收receive、读取read、等待链接accept 超时时间 核心是设置setSoTimeout)
 * @author   PJL
 * @package  Chapter4
 * @motto    学习需要毅力，那就秀毅力
 * @file     TimeLimitEchoProtocol.java
 * @time     2019年10月24日 下午10:54:00
 */
class TimelimitEchoProtocol implements Runnable {
	private static final int BUFSIZE = 32; // Size (bytes) buffer
	private static final String TIMELIMIT = "10000"; // Default limit (ms)
	private static final String TIMELIMITPROP = "Timelimit"; // Thread property

	private static int timelimit;
	private Socket clntSock;
	private Logger logger;

	public TimelimitEchoProtocol(Socket clntSock, Logger logger) {
		this.clntSock = clntSock;
		this.logger = logger;
		// Get the time limit from the System properties or take the default
		timelimit = Integer.parseInt(System.getProperty(TIMELIMITPROP, TIMELIMIT));
	}

	public static void handleEchoClient(Socket clntSock, Logger logger) {

		try {
			// Get the input and output I/O streams from socket
			InputStream in = clntSock.getInputStream();
			OutputStream out = clntSock.getOutputStream();
			int recvMsgSize; // Size of received message
			int totalBytesEchoed = 0; // Bytes received from client
			byte[] echoBuffer = new byte[BUFSIZE]; // Receive buffer
			long endTime = System.currentTimeMillis() + timelimit;
			int timeBoundMillis = timelimit;

			clntSock.setSoTimeout(timeBoundMillis);
			// Receive until client closes connection, indicated by -1
			while ((timeBoundMillis > 0) && // catch zero values
					((recvMsgSize = in.read(echoBuffer)) != -1)) {
				out.write(echoBuffer, 0, recvMsgSize);
				totalBytesEchoed += recvMsgSize;
				timeBoundMillis = (int) (endTime - System.currentTimeMillis());
				clntSock.setSoTimeout(timeBoundMillis);
			}
			logger.info("Client " + clntSock.getRemoteSocketAddress() + ", echoed " + totalBytesEchoed + " bytes.");
		} catch (IOException ex) {
			logger.log(Level.WARNING, "Exception in echo protocol", ex);
		}
	}

	public void run() {
		handleEchoClient(this.clntSock, this.logger);
	}
}

学习代码实例请参看：https://github.com/Nuclear-Core-Learning/TCPIP-Socket/tree/master/src/Chapter4

boonya
关注
专栏目录
IBM高级架构师结合多线程和Socket，深入实战微服务架构
Java_msb666的博客
09-08 380
前言 微服务架构的概念，现在对于大家应该都不陌生，无论使用 Apache Dubbo、还是 Spring Cloud，都可以去尝试微服务，把复杂而庞大的业务系统拆分成一些更小粒度且独立部署的 Rest 服务。但是你了解微服务的发展背景吗？接下来，咱们一块深入微服务的发展背景，也帮大家夯实一下微服务架构的技术发展。 面向服务的架构 1996年，Gartner 公司首次提出了面向服务的架构(Service-Oriented Architecture, SOA)这一软件设计思想。 其核心理念是将一.
Java的IO演进例实以及使用JDK自带的BIO编写BioServer服务端以及BioClient客户端分析通信优缺点示例
q736317048的博客
02-07 299
使用jdk自带的Bio编写一个同一时间服务 一个客户端请求过来服务返回对应的时间戳，每个请求都分一个线程 Step1：新建java项目 选取模板 Step2：创建Server服务端 public class BioServer { //定义服务端端口号 private static final int PORT = 8080; public static void main(String[] args) throws IOException { //建立So
socket 线程池实现（已经在项目中应用）
01-28
socket服务端线程池实现 不依赖于第三方jar，基于jdk编写。
socket 线程池
super_marioli的专栏
09-10 3020
import java.io.BufferedReader;import java.io.IOException;import java.io.InputStream;import java.io.InputStreamReader;import java.io.OutputStream;import java.io.PrintWriter;import java.net.
运用JAVA的concurrent.ExecutorService线程池实现socket的TCP和UDP连接
ane3232的博客
04-27 196
运用JAVA的concurrent.ExecutorService线程池实现socket的TCP和UDP连接 最近在项目中可能要用到socket相关的东西来发送消息，所以初步研究了下socket的TCP和UDP实现方式，并且结合java1.5的concurrent.ExecutorService类来实现多线程。 具体实现方式见代码： 一、TCP方式： 1、服务端实现方式： ...
Socket通讯解决并发采用线程池
02-29
Socket通讯解决并发采用线程池ThreadPool.java EchoServer.java EchoClient.java
socket 通信，聊天小程序
qq_38637728的博客
09-28 749
socket 通信## socket 通信 socket通信是网络中计算机进行通信的一种方法 客户端： public class SocketClientHandlerImpl implements Runnable { private Socket socket = null; private DataInputStream dataInputStream = null; private Dat...
Servlet容器中的多线程与并发处理技术
# 一、 理解Servlet容器中的多线程和并发处理技术 Servlet 容器作为 Java Web 应用程序的基础架构，在处理客户端请求时必须要考虑到多线程和...在本章节中，我们将深入探讨Servlet容器中的多线程模型，包括线程池的设
多线程编程概念与实践：C语言中的并发编程
## 1.2 多线程编程的优势与应用场景 多线程编程可以提高程序的并发性和性能，特别适合处理I/O密集型任务、并行计算和实时数据处理等场景。在图像处理、网络编程、服务器开发等领域都有广泛应用。 #
多线程与进程管理
# 1. 理解进程和线程 ## 1.1 什么是进程？ 在计算机科学中，进程是指程序在数据集合上的一次执行过程，是系统...一个进程可以拥有多个线程，在同一个进程中的多个线程可以共享该进程的所有资源，包括内存和文件句柄
java socket(线程池)
12-21
是一个java在进行socket编程时，关于线程池的介绍,有代码和例子
socket 线程池实现
12-22
一个很好的socket 线程池实现示例，希望对想了解线程池的朋友有所帮助
socket编程 使用select与线程池
01-15
建立TCP、UDP单播、组播 创建服务器端与客户端，服务器端使用select机制接收客户端的请求，并交给线程池处理
socket服务器线程池的实现
12-12
socket服务器侧的线程池的C++实现,已通过测试，非常好用，可运行在linux和windows环境
java socket 线程池_java socket编程（多任务处理，线程池）
weixin_39564524的博客
02-16 572
与为每个连接创建一个新的线程不同，服务器在启动时创建一个由固定数量线程组成的线程池(thread pool)，当一个新的客户端连接请求传入服务器，它将交给线程池中的一个线程处理。当该线程处理完这个客户端后，又返回线程池，并为下一次请求处理好准备。如果连接请求到达服务器时，线程池中的所有线程都已经被占用，它们则在一个队列中等待，直到有空闲的线程可用。服务器的简单示例代码如下import java.i...
Socket网络通信之线程池
weixin_30315905的博客
06-27 142
public static void main(String[] args) throws IOException { System.out.println("tcp协议服务器端启动.."); ExecutorService newCachedThreadPool = Executors.newCachedThreadPool();//线程池 // 创建服务器端连接 ServerSoc...
java socket 线程池_java socket编程的一个例子（线程池）
weixin_35160923的博客
02-16 492
服务器程序EchoServer.java；import java.io.*;import java.net.*;import java.util.concurrent.*;public class EchoServer {private int port=10000;private ServerSocket serverSocket;private ExecutorService executor...
c++ socket线程池_「Java」 - 多线程八 & 线程模型
weixin_39535752的博客
11-29 139
一、常用线程模型较早处理网络请求时，是使用一个Accept线程来轮询完成TCP三次连接的socket，然后每次接收到一个socket就开启一个线程进行处理。而线程是宝贵的资源，一个请求对应一个线程进行处理的模式，会很快耗尽系统资源。public 二、Tomcat请求的BIO线程模型Tomcat中BIO的线程模型本质是使用一个线程来接受连接请求，然后使用一个线程池来处理所有的请求，使用有限的线程来处...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值