多线程实现tcp聊天服务器

 

多线程tcp  server & client 

tcp服务端(多线程)：

from socket import *
from threading import Thread

def client(socket_client, msg_addr):
    print(">>>有新客户端连接<<<")
    try:
        while True:
            # 接受客户端发来的信息
            msg = socket_client.recv(1024)
            if msg:
                print("%s--> %s" % (msg_addr, msg.decode('utf-8')))
            else:
                print(msg_addr)
                print("客户端已断开连接...")
                break
    except:
        socket_client.close()


def main():
    #建立一个套接字， AF_INET 表示遵从IPv4协议，SOCK_STREAM（流） 表示使用的是tcp协议传输
    # 若使用UDP协议传输， 则使用SOCK_DGRAM(数据报）
    server = socket(AF_INET, SOCK_STREAM)

    # 重复使用绑定的信息
    # 此处若服务端成为tcp四次挥手的第一次，那么服务端最后将等待 2MSL 的时间来接受客户端可能发来的ack
    # 在这段时间内，若服务器想重复执行，之前被占用的端口等服务不被释放，导致服务器不能被执行
    #此处加上这句话则解决了这个问题
    server.setsockopt(SOL_SOCKET, SO_REUSEADDR, 1)

    msg_server = ("localhost", 7788)
    # 绑定本地的7788端口
    server.bind(msg_server)
    #开始监听
    #此处的listen中的值表示处于半连接和以连接状态的client总和
    server.listen(5)
    try:
        while True:
            #与客户端建立连接
            # socket_client表示为这个客户端创建出了包含tcp三次握手信息的新的套接字
            # msg_addr 包含这个客户端的信息
            socket_client, msg_addr = server.accept()
            #为每一个连接服务端的客户端创建出一个单独的线程，并传入上面的两个参数
            t = Thread(target=client, args=(socket_client,msg_addr))
            #在多线程中，创建的socket都共用一个socket_client,所以此时这个套接字不能被关闭
            #线程只是在cpu的某一个核心中不断的重复切换调用函数而已，所以数据其实都是一份，也是多线程中的数据可以共享的原因
            t.start()

    finally:
        server.close()

if __name__ == "__main__":
    main()

 tcp服务端(多进程)：

from socket import *
from multiprocessing import *

def client(socket_client, msg_addr):
    print(">>>有新客户端连接<<<")
    try:
        while True:
            msg = socket_client.recv(1024)
            if msg:
                print("%s--> %s" % (msg_addr, msg.decode('utf-8')))
            else:
                print(msg_addr)
                print("客户端已断开连接...")
                break
    except:
        socket_client.close()


def main():
    server = socket(AF_INET, SOCK_STREAM)
    server.setsockopt(SOL_SOCKET, SO_REUSEADDR, 1)

    msg_server = ("localhost", 7788)

    server.bind(msg_server)

    server.listen(5)
    try:
        while True:
            socket_client, msg_addr = server.accept()
            t = Process(target=client, args=(socket_client,msg_addr))
            #创建一个子进程时，会向子进程中复制一份资源，所以主进程中的套接字可以关闭
            #在多进程中，创建一个进程即表示占用某一个cpu的资源，创建的进程比较多时，这些进程就会在cpu之间轮流占用
            t.start()
            socket_client.close()

    finally:
        server.close()

if __name__ == "__main__":
    main()

 tcp客户端：

from socket import *

client = socket(AF_INET,SOCK_STREAM)

server_msg = ("localhost",7788)
#连接服务器
client.connect(server_msg)

while True:
    send = input("要发送的文本内容:")
    if send == 'q':
        break

    else:
        client.send((send).encode("utf-8"))
        print("发送成功！")

client.close()

关于tcp通信过程中的三次握手、四次挥手的过程

三次握手:

此过程中：

第一次握手，客户端先发一个SYN请求并附带一个J的值给服务端

第二次握手，服务端收到请求后解堵塞，发送一个SYN请求并附带一个K值，还发送了第一次握手后对客户端的响应包并附带在之前接收到的J值的基础上加上1，即J+1

第三次握手，客户端收到服务端发来的SYN请求和K值后，再发送一个K+1的响应包给服务端

至此，三次握手成功完成，客户端和服务端之间成功建立tcp链接

四次挥手：

此过程中：

第一次挥手：客户端调用了close，发送一个结束请求附带一个x+2的值，和一个y+1的响应包给服务端

第二次挥手：服务端发送x+3的响应包给客户端（其实每次的响应包的附带值都是在之前接收到的seq的值上加上1的结果）

第三次挥手：服务端调用close，发送一个结束seq附带一个y+1的值给客户端，此时服务端成功断开连接

第四次挥手：客户端接收到服务端的响应包和FIN请求后，回递一个y+2的响应包给服务端，此时的客户端进入time_wait状态，即继续等待2MSL的时间再完全断开链接（至于为什么要等待2MSL的时间，请看下文的MSL详解     ^_^     )

要点：在四次挥手的过程中，哪一方先调用close， 哪一方就会在第三次挥手后继续等待2MSL的时间

tcp通信过程中的2MSL的问题：

2MSL即为在四次挥手的第三次过程中，先发起中断连接的一方将会继续等待2倍的MSL时间后再完全中断tcp连接

MSL即为一个数据包在网络上存活的最长时间，即数据包从被发送到被接收所经历的最长时间

等待2倍的MSL时间就是因为防止服务端没收到最后一次的ACK，即在2MSL的时间内，若服务端没收到最后的ACK，在超时时间（MSL）后，服务端会认为客户端没收到第三次挥手中的FIN，这时服务端会再发一份FIN，这时一共经历了2MSL的时间，而客户端此时等待了2MSL的时间，正好可以接收这一次服务端重发的FIN请求，从而有效的保证了所有的请求和回应都会被对方接收