1.目標和思路

1.功能和目標： 類似群聊天
    [1]有人進入聊天室需要輸入姓名，姓名不能重復
    [2] 有人進入聊天室時，其他人會收到通知：
        *** 進入聊天室
    [3] 一個人發消息，其他人會收到：
        ×××　：××××××××
    [4] 有人退出聊天室，則其他人會收到通知：
        ×××　退出聊天室

２．確定技術模型
    [1] 使用字典保存用戶信息　{姓名：客戶端套接字}
    [2] 套接字選擇：　tcp套接字 
    [3] 轉換模型　：　客戶端－－>>服務端－－>>所有客戶端
    [4] 收發關系處理：　一個客戶端發送消息給服務端，服務端再轉發給其他客戶端
                    客戶端使用多進程來分別處理收發消息
                    服務端使用多線程來管理客戶端

３．具體實現流程
    [1] 搭建網絡連接
    [2] 實現登錄
            客戶端：　×　輸入姓名
                    ×　將姓名發送給服務端
                    ×　接收服務端反饋
                    ×　如果不允許進入則重新輸入，允許則進入聊天室
                    ×　創建新的進程用于收發消息

            服務端：  * 創建新的線程用于管理客戶端的連接
                    ×　接收姓名
                    ×　　判斷姓名是否存在
                    ×　　將結果反饋給客戶端
                    ×　不允許　登錄結束，允許登錄則將用戶信息插入數據機構保存
                    ×　將登錄信息通知其他人
    [3] 聊天
            客戶端：　×　循環發送消息
                    ×　循環接收消息
            
            服務器：　×　接收消息，判斷請求類型
                    ×　將消息轉發給其他用戶
    [4] 退出
            客戶端：　×輸入quit進行退出
                    ×　發送進程關閉，接收進程關閉

            服務器：　×　退出信息發送給其他人
                    ×　將其信息從服務器清除

2.客戶端代碼

import os,sys,signal
from socket import *

server_addr = (('127.0.0.1',9696))

def msg_recv(sockfd):       ##接收消息
    while True:
        data = sockfd.recv(1024)
        if data.decode() == 'q':
            break
        print(data.decode())

def msg_send(sockfd,name):      ##發送消息
    while True:
        try:
            data = input("發言>>")
        except KeyboardInterrupt:
            data = 'quit'
        if data == 'quit':  ##退出
            msg = 'Q %s'%name
            sockfd.send(msg.encode())
            break
        else:
            msg = 'C %s %s'%(data,name)
            sockfd.send(msg.encode())

def main():
    sockfd = socket()##創建套接字
    
    try:
        sockfd.connect(server_addr)
    except Exception:
        print("連接失敗")
        sockfd.close()
        return
    
    while True:             ####輸入姓名登錄
        name = input("請輸入昵稱:")
        sockfd.send(('L '+name).encode())   ## L 區分消息類型
        data = sockfd.recv(128)
        if data.decode() == 'OK':
            print("你已經進入9696聊天室")
            break
        else:
            print(data.decode())

    signal.signal(signal.SIGCHLD,signal.SIG_IGN)
    pid = os.fork()

    if pid < 0:
        sys.exit("err")  
    elif pid == 0:        ##子進程
        msg_recv(sockfd)
    else:
        msg_send(sockfd,name) 
    sys.exit("退出")
     

if __name__ == "__main__":
    main()

3.服務器代碼

from threading import Thread
from socket import *
import os,sys

Host = '0.0.0.0'
Post = 9696
address = (Host,Post)

chat_name = {}   ## name:conn
jobs = {}   ###conn:t  存儲線程對象t    
#conn_stat = {}   ###  conn:'true'  存儲套接字的狀態　true為運行　　false 為結束線程

def do_login(conn,name):        ##登錄
    if name not in chat_name:
        conn.send(b'OK')
    else:
        conn.send("昵稱已經存在".encode())
        return
    msg = "%s 進入9696聊天室" %name
    for c in chat_name:
        chat_name[c].send(msg.encode())
    chat_name[name] = conn

def do_chat(conn,msg,name):
    text = "%s :%s"%(name,msg)
    for n in chat_name:
        if n != name:
            chat_name[n].send(text.encode())

def do_quit(conn,name):
    msg = "%s 退出9696聊天室了"%name
    for c in chat_name:
        if c == name:
            conn.send(b'q')
        else:
            chat_name[c].send(msg.encode())
    del chat_name[name]
    #conn_stat[conn] = 'false'
    conn.close()

def do_request(conn):   ##用來處理客戶端的請求
    while True:
        data = conn.recv(1024).decode().strip().split(' ')
        if data[0] == 'L':   ##登錄
            name = data[-1]
            do_login(conn,name)
        elif data[0] == 'C':    ##聊天
            name = data[-1]
            msg = ''.join(data[1:-1])
            do_chat(conn,msg,name)
        elif data[0] == 'Q':  ##退出
            name = data[-1]
            do_quit(conn,name)
            break
        
def main():
    
    sockfd = socket()  ##tcp套接字
    sockfd.setsockopt(SOL_SOCKET,SO_REUSEADDR,1)    ##端口重用
    sockfd.bind(address)
    sockfd.listen(5)

    while True:
        try:
            conn,addr = sockfd.accept()
        except KeyboardInterrupt:
            sockfd.close()
            sys.exit("退出")
        except Exception as e:
            print(e)
            continue
        print("Connect from:",addr)
        t = Thread(target=do_request,args=(conn,))
        t.start()
        jobs[conn] = t
        #conn_stat[conn] = 'true'
        ###回收線程　　當有線程結束，只有當新的客戶端連接進來才會回收結束的線程
        for c in jobs:
            if c._closed is True:
                jobs[c].join()

if __name__ == '__main__':
    main()

4.運行結果

1.運行客戶端和服務器

2.輸入姓名

3.發送消息

4.退出客戶端

運行中收到的消息會顯示在“發言>>”之后，可以在其后加上“\r”讓光標回到行首，效果會好一點。。。。。