（5）基于socketserver实现并发

基于socketserver实现并发

多进程实现并发

【一】TCP协议实现并发

【1】客户端

# -*-coding: Utf-8 -*-
# @File : 客户端 .py
# author: Chimengmeng
# blog_url : https://www.cnblogs.com/dream-ze/
# Time：2023/6/23
from socket import *

client = socket(AF_INET, SOCK_STREAM)
client.connect(('127.0.0.1', 8080))

while True:
    msg_client = input('请输入指令:>>>>>').strip()

    if len(msg_client) == 0:
        continue

    client.send(msg_client.encode('utf8'))

    msg_from_server = client.recv(1024)
    print(msg_from_server.decode('utf8'))

【2】服务端

# -*-coding: Utf-8 -*-
# @File : 服务端 .py
# author: Chimengmeng
# blog_url : https://www.cnblogs.com/dream-ze/
# Time：2023/6/23

import socketserver


class MyRequestHandler(socketserver.BaseRequestHandler):
    def handle(self):
        # print(self.request) ---->  # 如果是 TCP 协议, self.request ----> conn
        # print(self.client_address) ---->  # 如果是 TCP 协议, self.client_address ----> ip + port
        print(self.request)
        print(self.client_address)

        # （2）任务二：拿到链接对象，与其进行通信循环 =====> handle方法
        while True:
            try:
                # 接收来自客户端的信息指令
                msg_from_client = self.request.recv(1024)

                if len(msg_from_client) == 0:
                    continue

                # 反馈信息给客户端
                msg_to_client = msg_from_client.upper()
                self.request.send(msg_to_client)

            except Exception as e:
                print(e)
                break

        self.request.close()


# （1）任务一：循环的从半连接池中取出链接请求与其建立双向链接，拿到链接对象

# 实例化链接对象
server = socketserver.ThreadingTCPServer(('127.0.0.1', 8088), MyRequestHandler)
# 创建链接循环 ---- 一直提供服务（死循环过程）
server.serve_forever()
'''
等同于以下操作

while True:
    conn,client_address = server.accept()
    # 启动一个线程(conn,client_address)
'''

【二】UDP协议实现并发

【1】服务端

# -*-coding: Utf-8 -*-
# @File : 服务端 .py
# author: Chimengmeng
# blog_url : https://www.cnblogs.com/dream-ze/
# Time：2023/6/23
import socketserver


class MyRequestHandler(socketserver.BaseRequestHandler):
    def handle(self):
        '''
        # print(self.request)
        # (b'hellow', <socket.socket fd=420, family=AddressFamily.AF_INET, type=SocketKind.SOCK_DGRAM, proto=0, laddr=('127.0.0.1', 8080)>)
        '''
        # 接收到的第一个数据是传入进来的信息
        msg_from_client = self.request[0]
        # 接收到的第二个数据是传入进来的链接对象
        server = self.request[1]

        client_address = self.client_address
        # ('127.0.0.1', 64418)

        # 回传数据
        msg_to_client = msg_from_client.upper()
        server.sendto(msg_to_client, client_address)


IP = '127.0.0.1'
PORT = 8080
server = socketserver.ThreadingUDPServer((IP, PORT), MyRequestHandler)
server.serve_forever()

'''
相当于
# 只负责循环的接收对象
while True:
    msg_from_client, client_address = server.recvfrom(1024)
    
    # 启动一个线程去处理后续的操作
    msg_to_client = msg_from_client.upper()
    server.sendto(msg_to_client, client_address)
'''

server.close()

【2】客户端

# -*-coding: Utf-8 -*-
# @File : 客户端 .py
# author: Chimengmeng
# blog_url : https://www.cnblogs.com/dream-ze/
# Time：2023/6/23

from socket import *

client = socket(AF_INET, SOCK_DGRAM)

while True:
    msg_to_server = input('请输入信息:>>>>>').strip()

    msg_to_server = msg_to_server.encode('utf-8')
    IP = '127.0.0.1'
    PORT = 8080
    client.sendto(msg_to_server, (IP, PORT))

    msg_from_server = client.recvfrom(1024)

    print(msg_from_server)

client.close()