运用JAVA的concurrent.ExecutorService线程池实现socket的TCP和UDP连接

最新推荐文章于 2021-02-21 03:57:03 发布

LzwGlory

最新推荐文章于 2021-02-21 03:57:03 发布

阅读量765

点赞数

分类专栏： java socket 文章标签： socket udp tcp java

java 同时被 2 个专栏收录

266 篇文章 4 订阅

订阅专栏

socket

3 篇文章 0 订阅

订阅专栏

最近在项目中可能要用到socket相关的东西来发送消息，所以初步研究了下socket的TCP和UDP实现方式，并且结合java1.5的concurrent.ExecutorService类来实现多线程。

具体实现方式见代码：

一、TCP方式：

1、服务端实现方式：

TCP的服务端实现方式主要用到ServerSocket类，接收等待客户端连接的方法是accept();

代码如下：类SocketServerTCP

 1 private int port = 8823;
 2     private ServerSocket serverSocket;
 3     private ExecutorService executorService;// 线程池
 4     private final int POOL_SIZE = 100;// 单个CPU线程池大小
 5 
 6     public SocketServerTCP() {
 7         try {
 8             serverSocket = new ServerSocket(port);
 9             executorService = Executors.newFixedThreadPool(Runtime.getRuntime()
10                     .availableProcessors() * POOL_SIZE);
11             logger.info("端口号为" + port + "的服务器启动");
12         } catch (IOException e) {
13             e.printStackTrace();
14         }
15     }
16 
17     public void service() {
18         System.out.println("socket初始化成功！");
19         logger.info("socket服务端初始化成功！");
20         while (true) {
21             Socket socket = null;
22             try {
23                 // 接收客户连接,只要客户进行了连接,就会触发accept();从而建立连接
24                 socket = serverSocket.accept();
25                 executorService.execute(new CallService(socket));
26             } catch (Exception e) {
27                 e.printStackTrace();
28             }
29         }
30     }

CallService类主要作用是接收到消息后，来实现具体业务。

代码如下：

 1 /**
 2  * 功能说明：执行具体业务的线程 
 3  */
 4   class CallService implements Runnable {
 5     Logger logger = Logger.getLogger(CallService.class);
 6     private Socket socket;
 7      
 8     private BufferedReader is;
 9     private PrintWriter os;
10  
11     public CallService(Socket socket) {
12         this.socket = socket;
13     }
14 
15     public void run() {
16         try {
17             is = new BufferedReader(new InputStreamReader(socket.getInputStream()));
18             os = new PrintWriter(socket.getOutputStream());
19 
20             String msg = is.readLine();
21 
22             System.out.println("接到客户端消息" + msg);
23             
24             //返回消息给客户端
25             String responseMsg="服务端返回消息：" + msg;
26             os.println(responseMsg);
27             os.flush();
28         } catch (IOException e) {
29             e.printStackTrace();
30         } finally {
31             try {
32                 if (os != null) {
33                     os.close();
34                 }
35                 if (is != null) {
36                     is.close();
37                 }
38                 if (socket != null) {
39                     socket.close();
40                 }
41             } catch (IOException e) {
42                 e.printStackTrace();
43             }
44         } 
45     }

服务器启动方式：

1 public static void main(String[] args) {
2         new SocketServerTCP().service();
3     }

2、TCP客户端实现代码

客户通过new Socket(ip, port)创建一个socket,并通过PrintWriter来向服务器发送消息

 1 public class SocketClientTCP {
 2     public String sendMsg(String ip, int port, String msg) {
 3         Socket client = null;
 4         try {
 5             // 创建Socket
 6             client = new Socket(ip, port);
 7 
 8             // 向服务器发送消息
 9             PrintWriter out = new PrintWriter(new BufferedWriter(
10                     new OutputStreamWriter(client.getOutputStream())), true);
11             out.println(msg);
12             out.flush();
13 
14             // 接收来自服务器的消息
15             BufferedReader in = new BufferedReader(new InputStreamReader(
16                     client.getInputStream()));
17             String str = in.readLine();
18             // 关闭流
19             out.close();
20             in.close();
21             // 关闭Socket
22             client.close();
23             return str;
24         } catch (IOException e) {
25             e.printStackTrace();
26         }
27         return "";
28     }
29 
30     public static void main(String[] args) {
31         SocketClientTCP client = new SocketClientTCP(); 
32         String str1 = client.sendMsg("127.0.0.1", 8823,"xiaoxi_1234567890A1234567!");
33         System.out.println("str1=====" + str1);
34     }
35 }

二、UDP实现方式

1、“服务端”实现方式

UDP的服务端主要是用到DatagramSocket、DatagramPacket类，通过new DatagramSocket(port)来创建一个socket，并且通过DatagramPacket来接收消息
代码如下：类SocketServerUDP:

 1 private int port = 1114;
 2     private DatagramSocket dataSocket;
 3     private ExecutorService executorService;// 线程池
 4     private final int POOL_SIZE = 100;// 单个CPU线程池大小
 5 
 6     public SocketServerUDP() {
 7         try {
 8             dataSocket = new DatagramSocket(port);
 9             executorService = Executors.newFixedThreadPool(Runtime.getRuntime()
10                     .availableProcessors() * POOL_SIZE);
11             logger.info("端口号为" + port + "的服务器启动");
12         } catch (IOException e) {
13             e.printStackTrace();
14         }
15     }
16 
17     public void service() {
18         System.out.println("socket初始化成功！");
19         logger.info("socket服务端初始化成功！");
20          
21         while (true) { 
22             try {
23                  byte[] buff = new byte[128];// 传输消息不超过64字  
24                  DatagramPacket dataPacket = new DatagramPacket(buff, buff.length);   
25                  dataSocket.receive(dataPacket);// 等待接收来自客户端的数据包   
26                  
27                  executorService.execute(new UdpCallService(dataPacket));//接收到消息后执行具体的业务
28             } catch (Exception e) {
29                 e.printStackTrace();
30             }
31         }
32     }

UDPCallService类主要作用是接收到消息后，来实现具体业务。

代码如下：

 1 class UdpCallService implements Runnable {
 2     Logger logger = Logger.getLogger(UdpCallService.class);
 3     private DatagramPacket packet;   
 4     private DatagramSocket dataSocket;   
 5 
 6     public UdpCallService(DatagramPacket packet) {   
 7         try {
 8             this.packet = packet;   
 9             // 创建本机可以端口的DatagramSocket   
10             dataSocket = new DatagramSocket();   
11         } catch (SocketException e) {   
12             e.printStackTrace();   
13         }   
14     }    
15 
16     public void run() {        
17             String str=new String(packet.getData());            
18             System.out.println("接收到消息："+str); 
19             //返回数据给客户端
20             responeSocket("UDP消息返回："+str);  
21     }
22     
23     //返回消息给客户端
24     public void responeSocket(String message){
25          // 构造响应数据包   
26         byte[] response = message.toString().getBytes();   
27         DatagramPacket dataPacket = new DatagramPacket(response, response.length, packet.getAddress(), packet.getPort());   
28         try {// 发送   
29             dataSocket.send(dataPacket);   
30         } catch (IOException e) {   
31             e.printStackTrace();   
32         }    
33     }

服务器启动方式：

1 public static void main(String[] args) {
2         new SocketServerUDP().service();
3     }

2、UDP客户端实现方式

UDP客户端的实现方式与"服务端"实现方式差不多，因为UDP本身就没有很严格的服务端和客户端定义。

代码如下：

 1 public class SocketClientUDP {
 2     
 3     private int PORT;
 4 
 5     public SocketClientUDP(int PORT) {
 6         this.PORT=PORT;
 7     }
 8 
 9     public String getMessage() {
10         String msg = "";
11         try {
12 
13             String str = "hello world ";
14             DatagramSocket socket = new DatagramSocket();
15 
16             // 发送UPD消息给服务端
17             DatagramPacket requestPacket = new DatagramPacket(str.getBytes(),
18                     str.length(), InetAddress.getLocalHost(), PORT);
19             socket.send(requestPacket);
20 
21             // 接收服务端返回的UDP消息
22             byte[] data = new byte[128];
23             DatagramPacket responsePacket = new DatagramPacket(data,data.length);
24             socket.receive(responsePacket);
25             msg = new String(responsePacket.getData(), 0,responsePacket.getLength());
26             socket.close();
27         } catch (UnknownHostException e) {
28             System.err.println("Exception: host could not be found");
29         } catch (Exception e) {
30             System.err.println("Exception: " + e);
31             e.printStackTrace();
32         }
33         return msg;
34     }
35     
36      public static void main(String[] args){
37           SocketClientUDP clientUdp = new SocketClientUDP(1114); 
38           String str1=   clientUdp.getMessage();
39           System.out.println("str1====="+str1); 
40      }