Question

我有一组进程，我们称之为A，B和C，需要彼此通信。需要与B和C沟通; B需要与A和C通信;和C需要与A和B通信.A，B和C可以位于不同的机器上或同一台机器上。

我的想法是通过套接字进行通信并使用“localhost”，如果它们都在同一台机器上（例如，A端口11111，B端口22222等）。这样，非本地进程将被视为本地进程。为此，我想我会为A，B和C中的每一个设置一个SocketServer实例，并且每个实例都知道其他两个的地址。每当需要进行通信时，例如A到B，A就会打开一个到B的套接字并写入数据。然后，B不断运行的服务器将读取数据并将其存储在列表中，以便以后在需要时使用。

我遇到的问题是，finish_request方法（正在处理监听）和__call__方法（处理通话）之间没有共享存储的信息。（服务器类是可调用的，因为我需要其他东西。我不相信这与问题有关。）

我的问题是，这是否会像我想象的那样起作用？ multiprocessing，threading和socketserver会在同一台机器上一起播放吗？我对使用其他机制在进程之间进行通信（如Queue或Pipe）不感兴趣。我有一个有效的解决方案。我想知道这种方法是否可行，即使效率较低。并且，如果是，我做错了什么阻止它工作？

说明问题的最小示例如下：

import uuid
import sys
import socket
import time
import threading
import collections
import SocketServer
import multiprocessing

class NetworkMigrator(SocketServer.ThreadingMixIn, SocketServer.TCPServer):
    def __init__(self, server_address, client_addresses, max_migrants=1):
        SocketServer.TCPServer.__init__(self, server_address, None)
        self.client_addresses = client_addresses
        self.migrants = collections.deque(maxlen=max_migrants)
        self.allow_reuse_address = True
        t = threading.Thread(target=self.serve_forever)
        t.daemon = True
        t.start()

    def finish_request(self, request, client_address):
        try:
            rbufsize = -1
            wbufsize = 0
            rfile = request.makefile('rb', rbufsize)
            wfile = request.makefile('wb', wbufsize)

            data = rfile.readline().strip()
            self.migrants.append(data)
            print("finish_request::  From: %d  To: %d  MID: %d  Size: %d -- %s" % (client_address[1], 
                                                                                   self.server_address[1], 
                                                                                   id(self.migrants), 
                                                                                   len(self.migrants), 
                                                                                   data))

            if not wfile.closed:
                wfile.flush()
            wfile.close()
            rfile.close()        
        finally:
            sys.exc_traceback = None

    def __call__(self, random, population, args):
        client_address = random.choice(self.client_addresses)
        migrant_index = random.randint(0, len(population) - 1)
        data = population[migrant_index]
        data = uuid.uuid4().hex
        sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
        try:
            sock.connect(client_address)
            sock.send(data + '\n')
        finally:
            sock.close()
        print("      __call__::  From: %d  To: %d  MID: %d  Size: %d -- %s" % (self.server_address[1], 
                                                                               client_address[1], 
                                                                               id(self.migrants), 
                                                                               len(self.migrants), 
                                                                               data))
        if len(self.migrants) > 0:
            migrant = self.migrants.popleft()
            population[migrant_index] = migrant
        return population


def run_it(migrator, rand, pop):
    for i in range(10):
        pop = migrator(r, pop, {})
        print("        run_it::  Port: %d  MID: %d  Size: %d" % (migrator.server_address[1], 
                                                                 id(migrator.migrants), 
                                                                 len(migrator.migrants)))
        time.sleep(1)


if __name__ == '__main__':
    import random
    r = random.Random()
    a = ('localhost', 11111)
    b = ('localhost', 22222)
    c = ('localhost', 33333)
    am = NetworkMigrator(a, [b, c], max_migrants=11)
    bm = NetworkMigrator(b, [a, c], max_migrants=22)
    cm = NetworkMigrator(c, [a, b], max_migrants=33)

    fun = [am, bm, cm]
    pop = [["larry", "moe", "curly"], ["red", "green", "blue"], ["small", "medium", "large"]]
    jobs = []
    for f, p in zip(fun, pop):
        pro = multiprocessing.Process(target=run_it, args=(f, r, p))
        jobs.append(pro)
        pro.start()
    for j in jobs:
        j.join()
    am.shutdown()
    bm.shutdown()
    cm.shutdown()

查看此示例的输出，将有三种类型的打印：

        run_it::  Port: 11111  MID: 3071227860  Size: 0
      __call__::  From: 11111  To: 22222  MID: 3071227860  Size: 0 -- e00e0891e0714f99b86e9ad743731a00
finish_request::  From: 60782  To: 22222  MID: 3071227972  Size: 10 -- e00e0891e0714f99b86e9ad743731a00

如果该实例中的id双端队列，则“MID”为migrants。 “From”和“To”是发送/接收传输的端口。我现在只是将数据设置为随机十六进制字符串，以便我可以跟踪单个传输。

我不明白为什么，即使使用相同的MID，它也会说它的大小非零，然后在稍后它会说它的大小是0.我觉得它必须源于这些调用是多线程的。如果使用这些行而不是最后的2个for循环，系统将以我期望的方式工作：

for _ in range(10):
    for f, p in zip(fun, pop):
        f(r, p, {})
        time.sleep(1)

那么打破它的多处理版本会发生什么？

Answer 1

当我们创建3个新的NetworkMigrator对象时，会启动3个新线程，每个线程都会侦听新的TCP连接。稍后，我们为run_it函数启动3个新进程。总共我们有4个进程，第一个进程包含4个线程（1个主要服务器+ 3个服务器）。现在，问题是其他3个进程无法访问侦听服务器线程对对象所做的更改。这是因为默认情况下进程不共享内存。

因此，如果您启动3个新线程而不是进程，您会注意到差异：

pro = threading.Thread(target=run_it,args=(f,r,p))

还有一个小问题。线程之间的这种共享也不是完全安全的。每当我们改变对象的状态时，最好使用锁。最好在finish_request和调用方法中执行类似下面的操作。

lock = Lock()
...
lock.acquire()    
self.migrants.append(data)
lock.release()

如果您对多线程不满意并且确实需要多处理，那么您可以使用代理对象，如下所述： http://docs.python.org/library/multiprocessing.html#proxy-objects

对于对象ID是相同的，这不是意料之外的。新进程在该时间点传递给对象的状态（包括对象ID）。新进程继续保留那些对象ID，但我们在这里谈论两个完全不同的内存空间，因为它们是不同的进程。因此，主进程所做的任何更改都不会反映在已创建的子进程中。

与SocketServer实例进行Python多处理通信

1 个答案: