Python 多线程猜数游戏

Question

Python 多线程猜数游戏

3

我正在编写一个网络猜数字游戏，希望您能对此提供一些帮助。除了处理多个客户端外，我的服务器还需要接受来自管理员客户端的连接。管理员客户端显示连接到服务器的玩家客户端的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()

- Pete

1个回答

网页内容由stack overflow 提供, 点击上面的

可以查看英文原文，
原文链接

- Rbtnk · Accepted Answer

这里有一个解决方案。它应该能够工作，但是需要注意两件事情：

您可能需要处理通信协议（我没有客户端代码，因此不知道如何处理接收到的数据）。
您可能需要添加一些循环来处理相同管理员/普通客户端的连续请求。

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

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

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

您可以使用：

如有需要，请评论以便更新。

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)