使用Python实现多线程、多进程、异步IO的socket通信

多线程实现socket通信服务器端代码

1. import socket
2. import threading
5. class MyServer(object):
6.     def __init__(self):
7.         # 初始化socket
8.         self.server = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
9.         # 设置服务器IP地址
10.         host = '192.168.152.1'
11.         # 设置服务器端口号
12.         port = 4321
13.         # 绑定IP地址和端口
14.         self.server.bind((host, port))
15.         # 设置最大监听数
16.         self.server.listen(5)
17.         # 设置一个字典，用来保存每一个客户端的连接和身份信息
18.         self.socket_mapping = {}
19.         # 设置接收的最大字节数
20.         self.maxSize = 1024
22.     def run(self):
23.         while True:
24.             socket, addr = self.server.accept()
25.             # 发送信息，提示客户端已成功连接
26.             socket.send('success！'.encode('utf-8'))
27.             # 将客户端socket等信息存入字典
28.             self.socket_mapping[socket] = addr
29.             # 创建线程，负责获取键盘输入并发送给客户端
30.             threading.Thread(target=self.send_to_client, args=(socket,)).start()
31.             # 创建线程，负责接收客户端信息并转发给其他客户端
32.             threading.Thread(target=self.recv_from_client, args=(socket,)).start()
34.     def send_to_client(self, socket):
35.         """
36.         获取键盘输入并发送给客户端
37.         :param socket:
38.         :return:
39.         """
40.         while True:
41.             info = input()
42.             if info == "quit":
43.                 socket.close()
44.             for socket in self.socket_mapping.keys():
45.                 socket.send(info.encode("utf-8"))
47.     def recv_from_client(self, socket):
48.         """
49.         接收客户端信息并转发给其他客户端
50.         :param socket:
51.         :return:
52.         """
53.         while True:
54.             recv_info = socket.recv(self.maxSize).decode('utf-8')
55.             print('client{} say: '.format(self.socket_mapping[socket]), recv_info)
56.             for i_socket in self.socket_mapping.keys():
57.                 if i_socket != socket:
58.                     i_socket.send(recv_info.encode("utf-8"))
61. my_server = MyServer()
62. my_server.run()

复制代码

多进程实现socket通信服务器端代码

存在的问题：在与客户端连通后，需要服务器先发送两条消息，之后才能正常通信。

1. import os
2. import socket
3. import sys
4. from multiprocessing import Process, Manager
7. class MyServer(object):
8.     def __init__(self):
9.         # 初始化socket
10.         self.server = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
11.         # 设置服务器IP地址
12.         host = '192.168.152.1'
13.         # 设置服务器端口号
14.         port = 4321
15.         # 绑定IP地址和端口
16.         self.server.bind((host, port))
17.         # 设置最大监听数
18.         self.server.listen(5)
19.         # 设置一个字典，用来保存每一个客户端的连接和身份信息
20.         self.socket_mapping = Manager().dict()
21.         # 设置接收的最大字节数
22.         self.maxSize = 1024
23.         # 进程锁
24.         self.share_lock = Manager().Lock()
26.     def run(self):
27.         fn = sys.stdin.fileno()
28.         while True:
29.             socket, addr = self.server.accept()
30.             # 发送信息，提示客户端已成功连接
31.             socket.send('success！'.encode('utf-8'))
32.             # 将客户端socket等信息存入字典
33.             self.modify_mapping(self.socket_mapping, addr, socket, self.share_lock)
34.             # 创建进程，负责获取键盘输入并发送给客户端
35.             Process(target=self.send_to_client, args=(addr, fn)).start()
36.             # 创建进程，负责接收客户端信息并转发给其他客户端
37.             Process(target=self.recv_from_client, args=(addr,)).start()
39.     def send_to_client(self, addr, fn):
40.         """
41.         获取键盘输入并发送给客户端
42.         :param addr:
43.         :return:
44.         """
45.         sys.stdin = os.fdopen(fn)
46.         while True:
47.             info = sys.stdin.readline()
48.             if info == "quit":
49.                 self.socket_mapping[addr].close()
50.             for socket in self.socket_mapping.values():
51.                 socket.send(info.encode("utf-8"))
53.     def recv_from_client(self, addr):
54.         """
55.         接收客户端信息并转发给其他客户端
56.         :param addr:
57.         :return:
58.         """
59.         while True:
60.             recv_info = self.socket_mapping.get(addr).recv(self.maxSize).decode('utf-8')
61.             print('client{} say: '.format(addr), recv_info)
62.             for i_addr in self.socket_mapping.keys():
63.                 if i_addr != addr:
64.                     self.socket_mapping.get(i_addr).send(recv_info.encode("utf-8"))
66.     @staticmethod
67.     def modify_mapping(share_var, share_key, share_value, share_lock):
68.         # 获取锁
69.         share_lock.acquire()
70.         # 修改数据
71.         share_var[share_key] = share_value
72.         # 释放锁
73.         share_lock.release()
76. if __name__ == "__main__":
77.     my_server = MyServer()
78.     my_server.run()

复制代码

异步IO实现socket通信服务器端代码

存在的问题：通信时需要相互发送几次消息后，各自才会收到之前的消息并打印。

1. import socket
2. import asyncio
3. import select
6. class MyServer(object):
7.     def __init__(self):
8.         # 初始化socket
9.         self.server = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
10.         # 设置服务器IP地址
11.         host = '192.168.152.1'
12.         # 设置服务器端口号
13.         port = 4321
14.         # 绑定IP地址和端口
15.         self.server.bind((host, port))
16.         # 设置最大监听数
17.         self.server.listen(5)
18.         # 设置一个字典，用来保存每一个客户端的连接和身份信息
19.         self.socket_mapping = {self.server: None}  # 这里存入self.server是为了充当select.select参数
20.         # 设置接收的最大字节数
21.         self.maxSize = 1024
22.         # 进入事件循环
23.         self.loop = asyncio.get_event_loop()
25.     def run(self):
26.         while True:
27.             # select监听请求对象
28.             rret, _, _ = select.select(self.socket_mapping.keys(), [], [])
29.             for r_socket in rret:
30.                 if r_socket is self.server:
31.                     socket, addr = r_socket.accept()
32.                     # 发送信息，提示客户端已成功连接
33.                     socket.send('success！'.encode('utf-8'))
34.                     # 将客户端socket等信息存入字典
35.                     self.socket_mapping[socket] = addr
36.                 else:
37.                     task = [self.send_to_client(r_socket), self.recv_from_client(r_socket)]
38.                     self.loop.run_until_complete(asyncio.gather(*task))
40.     async def send_to_client(self, socket):
41.         """
42.         获取键盘输入并发送给客户端
43.         :param socket:
44.         :return:
45.         """
46.         info = input()
47.         if info == "quit":
48.             socket.close()
49.         for socket in self.socket_mapping.keys():
50.             if socket != self.server:
51.                 socket.send(info.encode("utf-8"))
53.     async def recv_from_client(self, socket):
54.         """
55.         接收客户端信息并转发给其他客户端
56.         :param socket:
57.         :return:
58.         """
59.         recv_info = socket.recv(self.maxSize).decode('utf-8')
60.         print('client{} say: '.format(self.socket_mapping[socket]), recv_info)
61.         for i_socket in self.socket_mapping.keys():
62.             if i_socket != socket and i_socket != self.server:
63.                 i_socket.send(recv_info.encode("utf-8"))
66. my_server = MyServer()
67. my_server.run()

复制代码

客户端代码（使用多线程）

1. import socket
2. import threading
5. class MyClient(object):
6.     def __init__(self):
7.         # 初始化socket
8.         self.client = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
9.         # 设置服务器IP地址
10.         self.host = '192.168.152.1'
11.         # 设置服务器端口号
12.         self.port = 4321
13.         # 设置接收的最大字节数
14.         self.max_size = 1024
16.     def run(self):
17.         # 与服务器建立连接
18.         self.client.connect((self.host, self.port))
19.         # 创建线程，负责获取键盘输入并发送给服务器
20.         threading.Thread(target=self.sned_to_server).start()
21.         # 创建线程，接收服务器信息
22.         threading.Thread(target=self.recv_from_server).start()
24.     def sned_to_server(self):
25.         """
26.         获取键盘输入并发送给服务器
27.         """
28.         while True:
29.             send_msg = input()
30.             self.client.send(send_msg.encode('utf-8'))
31.             if send_msg == 'quit':
32.                 break
33.         self.client.close()
35.     def recv_from_server(self):
36.         """
37.         接收服务器信息
38.         """
39.         while True:
40.             recv_info = self.client.recv(self.max_size).decode('utf-8')
41.             print('server{} say: '.format((self.host, self.port)), recv_info)
44. my_client = MyClient()
45. my_client.run()

复制代码

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！