python 多线程多客户端服务器

Question

我正在用 python 编写一个多线程、多客户端服务器。多个用户可以通过 telnet 连接到它，基本上将它用作聊天服务器。我可以通过 telnet 连接两个客户端，但遇到以下两个问题：

1. 第一个发送消息的客户端立即断开连接。
2. 另一个客户端不会接收第一个客户端发送的消息。

服务器代码：

import os
import sys
import socket
import thread

port = 1941
global message
global lock
global file

def handler(connection):
    while 1:
            file = connection.makefile()
            file.flush()
            temp = file.readline()
            if temp == 'quit':
                break
            lock.acquire()
            message += temp
            lock.release()
            file.write(message)
    file.close()

acceptor = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
acceptor.bind(('', port))
acceptor.listen(10)
lock = thread.allocate_lock()

while 1:
    connection, addr = acceptor.accept()
    thread.start_new_thread(handler, (connection,))

好的，我听了 unholysampler，现在我有了这个。我现在可以连接两个客户端并输入消息，但它们没有被发送/接收（我不知道是哪一个）。

import os
import sys
import socket
import thread

port = 1953

def handler(connection):
    global message
    global filelist
    filelist = []
    file = connection.makefile()
    file.flush()
    filelist.append(file)
    message = ''
    while 1:
        i = 0
        while i < (len(filelist)):
            filelist[i].flush()
            temp = filelist[i].readline()

            if temp == 'quit':
                break

            with lock:
                message += temp

            i = i + 1
    file.close()

global lock
acceptor = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
acceptor.bind(('', port))
acceptor.listen(10)
lock = thread.allocate_lock()

while 1:
    connection, addr = acceptor.accept()
    thread.start_new_thread(handler, (connection,))

Answer 1

使用 Twisted 实现此类事情要简单得多，效果更好，它允许您在单个线程中同时处理多个客户端，以及提供更好的 API。

以下是如何使用 Twisted 编写聊天服务器（完整示例位于 聊天服务器中。 py)：

class MyChat(basic.LineReceiver):
    def connectionMade(self):
        print "Got new client!"
        self.factory.clients.append(self)

    def connectionLost(self, reason):
        print "Lost a client!"
        self.factory.clients.remove(self)

    def lineReceived(self, line):
        print "received", repr(line)
        for c in self.factory.clients:
            c.message(line)

    def message(self, message):
        self.transport.write(message + '\n')

对于每个用户，都会创建一个 MyChat 对象，事件循环会在开始/停止事件以及从客户端收到一行时调用其方法。在这种情况下，它只是将收到的每一行发送给系统中的所有客户端。由于它在单线程中运行，因此不需要锁。

Answer 2

这不是您使用global的方式。当您在方法作用域内定义方法时，可以使用全局命令来引用更高作用域的变量。

message = 1
def globalTest():
  global message
  message += 1
  print message

print message
globalTest()
print message

每次迭代循环时，您都会为连接创建一个新的文件对象。您想在循环开始之前进行此操作，因此只需执行一次。

您正在读取和写入同一个文件对象。这意味着它只是一个回显服务器。您永远不会向 thread1 提供对 thread2 文件的引用。尝试对套接字文件使用一个全局变量是行不通的，因为您永远不知道它实际上指向哪个套接字。 （问题#2）

您从不初始化消息，因此 message += temp 将抛出一个 UnboudLocalError ，表示在赋值之前它已被引用。 （可能是问题 #1 的原因）另外，为什么要首先附加字符串，这意味着每次发送内容时，整个对话都会发送出去。

另外，不要手动获取和释放锁，使用 with 更干净。

with lock:
  message += temp

Answer 3

我认为你需要在每次连接之前调用 s.listen 。也就是将其放入无限循环中。
当为真时：
接受器.listen(1)
#...