12 TCP服务器 IO多路复用

Posted 2020-10-17 不要被骄傲遮蔽了双眼

1.单进程服务器

from socket import *

serSocket = socket(AF_INET, SOCK_STREAM)

# 重复使用绑定的信息
serSocket.setsockopt(SOL_SOCKET, SO_REUSEADDR  , 1)

localAddr = (\'\', 7788)

serSocket.bind(localAddr)

serSocket.listen(5)

while True:

    print(\'-----主进程，，等待新客户端的到来------\')

    newSocket,destAddr = serSocket.accept()

    print(\'-----主进程，，接下来负责数据处理[%s]-----\'%str(destAddr))

    try:
        while True:
            recvData = newSocket.recv(1024)
            if len(recvData)>0:
                print(\'recv[%s]:%s\'%(str(destAddr), recvData))
            else:
                print(\'[%s]客户端已经关闭\'%str(destAddr))
                break
    finally:
        newSocket.close()

serSocket.close()

 　　　　

　总结

• 同一时刻只能为一个客户进行服务，不能同时为多个客户服务
• 类似于找一个“明星”签字一样，客户需要耐心等待才可以获取到服务
• 当recv接收数据时，返回值为空，即没有返回数据，那么意味着客户端已经调用了close关闭了；因此服务器通过判断recv接收数据是否为空 来判断客户端是否已经下线

 

2.如何实现并发的？

from socket import *
from multiprocessing import Pool

serSocket = socket(AF_INET, SOCK_STREAM)
serSocket.setsockopt(SOL_SOCKET, SO_REUSEADDR  , 1)
                                                #1表示端口可以充分使用，不会出现already used
localAddr = (\'\', 7788)
serSocket.bind(localAddr)
serSocket.listen(5)

def dealWithClient(newSocket,destAddr):
    while True:
        recvData = newSocket.recv(1024)
        if len(recvData)>0:
            print(\'recv[%s]:%s\'%(str(destAddr), recvData))
        else:
            print(\'[%s]客户端已经关闭\'%str(destAddr))
            break
    newSocket.close()

def main():
    while True:
        print(\'-----主进程，，等待新客户端的到来------\')
        newSocket,destAddr = serSocket.accept()
        print(\'-----主进程，，接下来负责数据处理[%s]-----\'%str(destAddr))

        client = Pool(targetc=dealWithClient,args=(newSocket,destAddr))
        client.start()

        newSocket.close()  #新的进程以及有套接字，此时的套接字，不需要了

    serSocket.close()

if __name__ == "__main__":
    main()

 

3. 多进程服务器：进程占用的资源多

from socket import *
from multiprocessing import *
from time import sleep

# 处理客户端的请求并为其服务
def dealWithClient(newSocket,destAddr):
    while True:
        recvData = newSocket.recv(1024)
        if len(recvData)>0:
            print(\'recv[%s]:%s\'%(str(destAddr), recvData))
        else:
            print(\'[%s]客户端已经关闭\'%str(destAddr))
            break

    newSocket.close()


def main():

    serSocket = socket(AF_INET, SOCK_STREAM)
    serSocket.setsockopt(SOL_SOCKET, SO_REUSEADDR  , 1)
    localAddr = (\'\', 7788)
    serSocket.bind(localAddr)
    serSocket.listen(5)

    try:
        while True:
            print(\'-----主进程，，等待新客户端的到来------\')
            newSocket,destAddr = serSocket.accept()

            print(\'-----主进程，，接下来创建一个新的进程负责数据处理[%s]-----\'%str(destAddr))
            client = Process(target=dealWithClient, args=(newSocket,destAddr))
            client.start()

            #因为已经向子进程中copy了一份（引用），并且父进程中这个套接字也没有用处了
            #所以关闭
            newSocket.close()
    finally:
        #当为所有的客户端服务完之后再进行关闭，表示不再接收新的客户端的链接
        serSocket.close()

if __name__ == \'__main__\':
    main()

• 通过为每个客户端创建一个进程的方式，能够同时为多个客户端进行服务
• 当客户端不是特别多的时候，这种方式还行，如果有几百上千个，就不可取了，因为每次创建进程等过程需要好较大的资源

 　　　　

• 写时copy：进程先调用，不到万不得已，才copy一份

　　　　

 

4.多线程服务器：线程共用同一份进程资源

#coding=utf-8
from socket import *
from threading import Thread
from time import sleep

# 处理客户端的请求并执行事情
def dealWithClient(newSocket,destAddr):
    while True:
        recvData = newSocket.recv(1024)
        if len(recvData)>0:
            print(\'recv[%s]:%s\'%(str(destAddr), recvData))
        else:
            print(\'[%s]客户端已经关闭\'%str(destAddr))
            break

    newSocket.close()


def main():

    serSocket = socket(AF_INET, SOCK_STREAM)
    serSocket.setsockopt(SOL_SOCKET, SO_REUSEADDR  , 1)
    localAddr = (\'\', 7788)
    serSocket.bind(localAddr)
    serSocket.listen(5)

    try:
        while True:
            print(\'-----主进程，，等待新客户端的到来------\')
            newSocket,destAddr = serSocket.accept()

            print(\'-----主进程，，接下来创建一个新的进程负责数据处理[%s]-----\'%str(destAddr))
            client = Thread(target=dealWithClient, args=(newSocket,destAddr))
            client.start()

            #因为线程中共享这个套接字，如果关闭了会导致这个套接字不可用，
            #但是此时在线程中这个套接字可能还在收数据，因此不能关闭
            #newSocket.close() 
    finally:
        serSocket.close()

if __name__ == \'__main__\':
    main()

 

•  模拟tcp客户端，多线程可以连接

 　　　　

 

5.单进程服务器：非阻塞模式

#将套接字设置为非堵塞
    #设置为非堵塞后，如果accept时，恰巧没有客户端connect，那么accept会
    #产生一个异常，所以需要try来进行处理
    serSocket.setblocking(False)

 

from socket import *
#1.创建socket
serSocket = socket(AF_INET, SOCK_STREAM)

#2. 绑定本地ip以及port
localAddr = (\'\', 7788)
serSocket.bind(localAddr)

#3. 让这个socket 变为非堵塞
serSocket.setblocking(False)

#4. 将socket变为监听（被动）套接字
serSocket.listen(100)

# 用来保存所有已经连接的客户端的信息
clientAddrList = []

while True:

    #等待一个新的客户端的到来（即完成3次握手的客户端）
    try:
        clientSocket,clientAddr = serSocket.accept()
    except:
        pass
    else:
        print("一个新的客户端到来：%s"%str(clientAddr))
        clientSocket.setblocking(False)
        clientAddrList.append((clientSocket,clientAddr))

    for clientSocket,clientAddr in clientAddrList:
        try:
            recvData = clientSocket.recv(1024)
        except:
            pass
        else:
            if len(recvData)>0:
                print("%s:%s"%(str(clientAddr), recvData))
            else:
                clientSocket.close()
                clientAddrList.remove((clientSocket, clientAddr))
                print("%s 已经下线"%str(clientAddr))