python在2个进程之间共享manager.dict（）中的线程对象

Question

我想在2个进程之间共享线程对象的字典。 我还有另外一个关于对象的指令，该指令目前似乎可以使用。

问题是，当我尝试将键/值对添加到dict时，它引发了一个异常（ key是整数， value是线程对象）：

Exception with manager.dict()
    TypeError: can't pickle _thread.lock objects

我尝试从manager.dict()切换到manager.list() ，它也不起作用：

Exception with manager.list()
    TypeError: can't pickle _thread.lock objects

readFiles()函数正常运行。

我使用python 3.5.1（Anaconda）

def startAlgorithm(fNameGraph, fNameEnergyDistribution, fNameRouteTables):
    global _manager, _allTiesets, _allNodes, _stopDistribution

    _manager = Manager()
    _allTiesets = _manager.dict()
    _allNodes = _manager.dict()

    _stopDistribution = Value(c_bool, False)

    readFiles(fNameGraph, fNameEnergyDistribution, fNameRouteTables)
    initializeAlgorithm()

    procTADiC = Process(target=TADiC, args=(_stopDistribution, _allNodes))
    procTA = Process(target=TIESET_AGENT, args=(_stopDistribution, _allNodes, _allTiesets))
    procTADiC.start()
    procTA.start()

    procTADiC.join()
    procTA.join()


def initializeAlgorithm():
    global _graphNX, _routingTable, _energyDistribution, _energyMeanValue

    #Init all Nodes
    allNodeIDs = _graphNX.nodes()
    energySum = 0
    for node in allNodeIDs:
        nodeEnergyLoad = float(_energyDistribution.get(str(node)))
        nodeObj = Node(node, nodeEnergyLoad)
        _allNodes[node] = nodeObj
        energySum = energySum + nodeEnergyLoad

    #Calculate the mean value from the whole energy in the graph
    _energyMeanValue = energySum / len(allNodeIDs)

    #Init all Tieset-Threads
    for tieset in _routingTable:
        tiesetID = int(tieset['TiesetID'])
        connNodes = list(tieset['Nodes'])
        connEdges = list(tieset['Edges'])
        adjTiesets = list(tieset['AdjTiesets'])
        tiesetThread = Tieset(tiesetID, connNodes, connEdges, adjTiesets)
        _allTiesets[tiesetID] = tiesetThread        # Raise Exception!!!!!!!!!!


class Node:
    'Node-Class that hold information about a node in a tieset'

    def __init__(self, nodeID, energyLoad):
        self.nodeID = nodeID
        self.energyLoad = energyLoad
        self.tiesetFlag = False


class Tieset(threading.Thread):
    'Tieset-Class as Thread to distribute the load within the tieset'

    def __init__(self, tiesetID, connectedNodes, connectedEdges, adjTiesets):
        threading.Thread.__init__(self)
        self.tiesetID = tiesetID
        self.connectedNodes = connectedNodes
        self.connectedEdges = connectedEdges
        self.adjTiesets = adjTiesets
        self.leaderNodeID = min(int(n) for n in connectedNodes)
        self.measureCnt = 0


    def run(self):
        print('start Thread')

Answer 1

我可以说您不能在进程之间共享线程，如果您想在不同的进程中启动它们，则可以共享这些线程的参数，或者可以共享一些结果。 您所看到的问题是由该进程创建的性质引起的，在python中，所有参数都将在当前进程中序列化，然后传递给新参数，然后python在此处反序列化它们以运行“目标”。 显然，线程对象不可序列化（您可以检查此有趣的线程以了解调试pickle的序列化问题）。