python线程猜谜游戏

Question

我正在编写一个联网的数字猜谜游戏，需要一些帮助才能完成。除了处理多个客户端之外，我的服务器还需要接受来自管理客户端的连接。 Admin 客户端显示连接到服务器的播放器客户端的 IP 地址和端口号列表。我知道我需要实现线程才能实现这一目标。

到目前为止，这是我的代码。我不确定需要多少个线程以及如何将连接的玩家客户端的信息传递到线程中。

#Server
import threading
import socket
import math
import random
import ssl

def within(guess,goal,n):
    absValue = abs(guess - goal)
    if absValue <= n:
        return True
    else:
        return False

#def HandleAdmin(adminSocket):
    #(conn,addr) = adminSocket.accept()
    #ts = ssl.wrap_socket(conn, certfile="5cc515_server.crt",
                             #keyfile="5cc515_server.key",
                             #server_side=True,
                             #cert_reqs=ssl.CERT_REQUIRED,
                             #ca_certs="5cc515-root-ca.cer")

    #if ts.recv(80).decode() == 'Hello\r\n':
        #ts.send('Admin-Greetings\r\n'.encode())
    #if ts.recv(80).decode() == 'Who\r\n':
        #ts.send((c,a).encode())
    #ts.close()
    #return

def HandleClient(c,a):
    scoreCount = 0
    guess = 0
    if(c.recv(80).decode()) == 'Hello\r\n':
        c.send('Greetings\r\n'.encode())

        goal = random.randrange(1,21)

        while guess!= goal:
            guess =c.recv(80).decode()
            guess = int(guess[7:len(guess)-2])

            if guess == goal:
                c.send('Correct\r\n'.encode())
            elif within(guess, goal, 2) == True:
                c.send('Close\r\n'.encode())
            else:
                c.send('Far\r\n'.encode())
    c.close()
    return

clientSocket = socket.socket(socket.AF_INET,socket.SOCK_STREAM)
clientSocket.bind(("127.0.0.1",4000))
clientSocket.listen(5)

adminSocket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
adminSocket.bind(("127.0.0.1",4001))
adminSocket.listen(5)

while True:
    (c,a) = clientSocket.accept()
    #handleAdminThread = threading.Thread(target = AcceptAdminConnection,
     #                                        args = adminSocket)

    clientThread = threading.Thread(target = HandleClient, args = (c,a))
    clientThread.start()

Answer 1

所以这是一个解决方案。它应该可以工作，但有一些事情需要注意:

• 你可能需要注意你的通信协议(protocol)(我这里没有客户端代码，所以我不知道它是如何处理的收到数据)。
• 你可能需要添加一些循环来处理同一管理员/普通客户端的连续请求。

我并没有尝试改进您的代码只是为了添加您要求的内容，所以它可能不是最好的解决方案至少它还没有完成。

它是这样工作的:你创建了 2 个 TCPServer 实例，一个用于处理管理连接，另一个用于客户端。每个实例都有一个 BaseRequestHandler。
基本上，服务器监听连接并自动启动一个新线程，为每个连接调用请求处理程序。

现在要共享数据，您可以使用任何变量，这里是一个字典，并在线程之间共享它。通过将字典设置为服务器成员，您可以从请求处理程序访问字典。为了保护对共享字典的访问，有一个锁(即互斥锁)，它像字典一样共享。

你可以使用:

• the documentaion on socketserver
• the documentaion on lock

如有需要请评论我会更新。

import threading
import socketserver
import ssl
import random


class ThreadedTCPAdminRequestHandler(socketserver.BaseRequestHandler):
    def handle(self):

        ts = self.request # replaced the ssl connection for simpler code
        msg = ts.recv(80).decode()
        # Here should be some kind of loop to be able to handle multiple request of the same admin client
        # like 'Hello' followed by 'Who'
        if msg == 'Hello':
            ts.send('Admin-Greetings\r\n'.encode())
        elif msg == 'Who':
            with self.server.addressesLock:
                # get a local copy of the dict and quickly release the lock
                socket_addresses = self.server.addresses.copy()
            client_string=''
            # print the list of threads with their address:port
            for threadName, socket_addresse in socket_addresses.items():
                client_string += threadName + ' ' + socket_addresse + '\r\n'
                # the admin handler doesn't anything if the following line is commented
                # ts.send(client_string.encode())

            #  for simpler test, that way you can see the connexion listing is working
            # even if there are conection problems
            print(client_string)
            ts.send('plop'.encode())


class ThreadedTCPClientRequestHandler(socketserver.BaseRequestHandler):
    def handle(self):
        cur_thread = threading.current_thread().name
        with self.server.addressesLock:  # use a lock to protect the access to the shared dict
            # add name of the thread ad key and the address:port as value in the global dict
            self.server.addresses[cur_thread] = self.client_address[0] + ':' + str(self.client_address[1])

        score_count = 0
        guess = 0
        if (self.request.recv(80).decode()) == 'Hello':
            self.request.send('Greetings\r\n'.encode())

            goal = random.randrange(1, 21)

            while guess != goal:
                guess = self.request.recv(80).decode()
                guess = int(guess[7:len(guess) - 2])

                if guess == goal:
                    self.request.send('Correct\r\n'.encode())
                elif guess in range(goal-2,goal +2):
                    self.request.send('Close\r\n'.encode())
                else:
                    self.request.send('Far\r\n'.encode())

        with self.server.addressesLock:  # use a lock to protect the access to the shared dict
            del self.server.addresses[cur_thread]  # delete the thread entry in the dict


class ThreadedTCPServer(socketserver.ThreadingMixIn, socketserver.TCPServer):
    pass


if __name__ == "__main__":
    C_HOST, C_PORT = 'localhost', 4000
    A_HOST, A_PORT = 'localhost', 4001

    clientServer = ThreadedTCPServer((C_HOST, C_PORT), ThreadedTCPClientRequestHandler)
    adminServer = ThreadedTCPServer((C_HOST, A_PORT), ThreadedTCPAdminRequestHandler)

    # Start a thread for each the server (client and admin) -- those threads will then start one
    # more thread for each request
    clientServer_thread = threading.Thread(target=clientServer.serve_forever)
    adminServer_thread = threading.Thread(target=adminServer.serve_forever)

    addresses = {}  # create a dict to store the addresses of connected clients
    addressesLock0 = threading.Lock()  # create a lock to protect access to the dict

    clientServer_thread.daemon = True  # client will terminate when main terminate
    clientServer.addresses = addresses  # share the addreses dict
    clientServer.addressesLock = addressesLock0  # share the lock
    adminServer_thread.daemon = True
    adminServer.addresses = addresses
    adminServer.addressesLock = addressesLock0

    try:
        # strart servers
        clientServer_thread.start()
        print("clientServer loop running in thread:", clientServer_thread.name)
        adminServer_thread.start()
        print("adminServer loop running in thread:", adminServer_thread.name)

        input('Press Enter to exit...\r\n')  # wait input to end the program

    finally:
        # stop servers
        clientServer.shutdown()
        clientServer.server_close()
        adminServer.shutdown()
        adminServer.server_close()
    exit(0)