python tcp单线程服务器和多线程服务器

以下是摘自自己项目的部分代码，仅供参考。

单线程服务器：

from socket import *
import os
import sys
import json
import time
__dir__ = os.path.dirname(os.path.abspath(__file__))
sys.path.append(__dir__)
sys.path.append(os.path.abspath(os.path.join(__dir__, '../')))

import cv2
import utility
import ocrService

import numpy as np
from PIL import Image
from ppocr.utils.logging import get_logger
logger = get_logger()

HOST = ''
PORT = 7777
BUFSIZ = 1024
ADDR = (HOST, PORT)

tcpSerSock = socket(AF_INET, SOCK_STREAM)   #创建套接字
tcpSerSock.bind(ADDR)   #绑定IP和端口
tcpSerSock.listen(5)    #监听端口，最多5人排队

print('waiting for connection...')
new_client_socket, client_addr = tcpSerSock.accept()    #建立连接
print('...connected from:', client_addr)

while True:
    recv_date = new_client_socket.recv(BUFSIZ)
    starttime = time.time()
    if recv_date:  # 使服务器能一直收到信息，只有客户端断开时，才退出循环
        print("从客户端" + str(client_addr[0]) + ":" + str(client_addr[1]) + "接收到的数据为:", recv_date.decode("utf-8"))
        args = utility.parse_args()
        args.det_model_dir = "./inference/det"
        args.rec_model_dir = "./inference/rec"
        args.use_gpu = False

        time1 = time.time()
        elapse = time1 - starttime
        logger.info("接收客户端数据等待时间 time : %.3fs----------------------" % elapse)
        ### 检测和识别
        result_data = ocrService.get_wrong_data('./tcp/1.bmp', args)
    else:
        break

    time2 = time.time()
    elapse = time2 - time1
    logger.info("总共时间 time : %.3fs----------------------" % elapse)
    # 发送数据
    send_date = json.dumps(result_data, ensure_ascii=False)
    print("response---->", send_date)
    new_client_socket.send(send_date.encode("utf-8"))

new_client_socket.close()
tcpSerSock.close()

多线程服务器：

import socket
import threading
import multiprocessing
import os
import sys
import json
import time
__dir__ = os.path.dirname(os.path.abspath(__file__))
sys.path.append(__dir__)
sys.path.append(os.path.abspath(os.path.join(__dir__, '../')))

import cv2
import utility
import ocrService

import numpy as np
from PIL import Image
from ppocr.utils.logging import get_logger
logger = get_logger()

def client1(socket_tcp_server):  # 采用了多线程
    # accept等待客户端连接
    # 如果有新的客户来连接服务器，那么就产生一个新的套接字连接客户端服务
    # new_client_socket用来为这个客户端服务
    # socket_tcp_server就可以省下专门等待其他客户连接
    new_client_socket, client_addr = socket_tcp_server.accept()  # 当服务器得到客户端请求连接时，client_flag=1
    print("客户端连接成功", client_addr)

    while True:
        # 接收数据
        recv_date = new_client_socket.recv(1024)  # 当客户端断开连接时,recv_date的值为空

        if recv_date:  # 使服务器能一直收到信息，只有客户端断开时，才退出循环
            starttime = time.time()
            print("从客户端" + str(client_addr[0]) + ":" + str(client_addr[1]) + "接收到的数据为:", recv_date.decode("utf-8"))
            args = utility.parse_args()
            args.det_model_dir = "./inference/det"
            args.rec_model_dir = "./inference/rec"
            args.use_gpu = False

            ### 检测和识别
            result_data = ocrService.get_wrong_data('./tcp/1.bmp', args)

            time1 = time.time()
            elapse = time1 - starttime
            logger.info("总共时间 time : %.3fs----------------------" % elapse)
        else:
            break

        # 发送数据
        send_date = json.dumps(result_data,ensure_ascii=False)
        print("response---->", send_date)
        new_client_socket.send(send_date.encode("utf-8"))

    new_client_socket.close()  # 关闭这个套接字

    print("对方已经结束了会话，等待新的连接")


def main():
    global client_flag
    socket_tcp_server = socket.socket(socket.AF_INET, socket.SOCK_STREAM)  # 定义一个监听套接字
    socket_addr = ("", 7777)
    socket_tcp_server.bind(socket_addr)  # 服务器绑定一个端口
    socket_tcp_server.listen(128)  # listen使套接字转变为被动连接，即类似等待客户端连接，而不是主动虚招客户端
    print("等待一个新客户端连接....")

    while True:
        client1_threading = threading.Thread(target=client1, args=(socket_tcp_server,))  # 新建一个线程
        client1_threading.start()  # 开启这个线程


if __name__ == '__main__':
    main()

测试客户端：

import socket
import threading


def send_date(socket_tcp_client):  # 发送数据
    while True:
        server_date = input()
        # 3.发送信息
        if server_date == "exit":  # 当输入exit时，断开于服务器的连接
            break
        else:
            socket_tcp_client.send(server_date.encode("gbk"))  # 发数据,enconde为编码 gbk为编码方式

    socket_tcp_client.close()  # 关闭套接字


def recv_date(socket_tcp_client):  # 接收数据

    while True:
        recv_date = socket_tcp_client.recv(1024)  # 接收信息，每次最大为1024

        print("接收到的数据为:", recv_date.decode("gbk"))  # decode为解码，gbk为解码方式
        print("请输入要发送的数据:", end=" ")


def main():
    socket_tcp_client = socket.socket(socket.AF_INET, socket.SOCK_STREAM)  # 创建一个套接字
    server_ip = "192.168.1.120"
    server_port = 7777
    print("请输入要发送的数据，输入exit退出会话:", end=" ")

    server_addr = (server_ip, server_port)
    socket_tcp_client.connect(server_addr)  # 2.绑定连接

    send_tcp_date = threading.Thread(target=send_date, args=(socket_tcp_client,))  # 定义两个线程，分别为发送和接收
    recv_tcp_date = threading.Thread(target=recv_date, args=(socket_tcp_client,))
    send_tcp_date.start()
    recv_tcp_date.start()  # 开启这两个线程


if __name__ == '__main__':
    main()

单线程服务器意义不大，一个客户端连接上后出于挂起占用状态，其他客户端不能访问服务器。