Question

所以，我正在为Autodesk Maya编写一个免费的python任务服务器，它拥有x个“worker”的队列。在任何时候，服务器都可以接受“任务”并将该任务扔到工作人员流失的队列中。

每个工作人员从队列中获取一个'taskDict'，这是一个发送到服务器的字典，说明Maya文件的位置，以及打开无头Maya应用程序时运行的代码（mayapy.exe / standalone）

我已经多次重写，首先使用我自己的队列系统，但后来我决定使用python。接下来使用池，使用Queue.Queue，使用mp.Manager.Queue和池等。我很难找到一个简单的多线程服务器的例子，它接收信息并启动一个线程，但是当它使用队列时得到的请求太多了。

我只是从根本上不了解如何将信息放入队列中，并通过队列进行mp.pool流失，启动使用该数据的apply_async进程并在完成时告知队列。

以下是代码的当前状态：

import tempfile
import os
import subprocess
import threading
import multiprocessing as mp
import socket
import sys

from PySide import QtGui, QtCore

import serverUtils

selfDirectory = os.path.dirname(__file__)
uiFile = selfDirectory + '/server.ui'
if os.path.isfile(uiFile):
    form_class, base_class = serverUtils.loadUiType(uiFile)
else:
    print('Cannot find UI file: ' + uiFile)


def show():
    global mayaTaskServerWindow
    try:
        mayaTaskServerWindow.close()
    except:
        pass

        mayaTaskServerWindow = mayaTaskServer()
        mayaTaskServerWindow.show()
    return mayaTaskServerWindow

class MayaTaskServer(base_class, form_class):
    refreshSignal = QtCore.Signal()

    def __init__(self):
        super(MayaTaskServer, self).__init__()

        self.setupUi(self)

        self.mainJobServer = None
        self.mpPool = None
        self.manager = None
        self.q = None

        self.workerDict = {}

        self.refreshSignal.connect(self.refreshTree)
        self.startLocalCoresBTN.clicked.connect(self.startLocalCoresFn)
        self.killLocalCoresBTN.clicked.connect(self.killLocalCoresFn)
        self.jobTree.setContextMenuPolicy(QtCore.Qt.CustomContextMenu)
        self.jobTree.customContextMenuRequested.connect(self.openMenu)

        self.startJobServer(6006)
        self.startQueue()

        # set the default temp folder
        filepath = os.path.realpath(__file__)
        self.localTempFolderEDT.setText(filepath.replace(filepath.split('\\')[-1], ''))

    ## JOB SYSTEM
    ####################################################################

    class MayaWorker(object):
        def __init__(self, host, port, cpuID):
            self.host = host
            self.port = port
            self.location = None
            self.cpuID = cpuID

            self.location = self.host

            self.busy = False
            self.task = None
            self.taskHistory = {}

        def runTask(self, task):
            print 'starting task - ', self.task['description']
            self.busy = True
            serverUtils.spawnMaya(task)
            win.refreshSignal.emit()

        def taskComplete(self, arg):
            self.busy = False
            self.task = None
            self.mayaFile = None
            win.refreshSignal.emit()

    def bootUpLocalWorkers(self, numProcs):
        self.mpPool = mp.Pool(processes=numProcs)
        for i in range(0, numProcs):
            mw = self.MayaWorker('localhost', 6006, i)
            win.mpPool.apply_async(mw, args=(win.q))
            win.workerDict['CPU_' + str(i)] = mw

    ## USER INTERFACE
    ####################################################################

    #UI code here you don't care about

    ## JOB LISTENER / SERVER / QUEUE
    ####################################################################
    class JobServer(threading.Thread):
        def __init__(self, port):
            threading.Thread.__init__(self)
            self.server_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
            self.server_socket.bind(('localhost', port))
            self.server_socket.listen(5)

            self.port = port
            self.running = True

            self.mpPool = None

        def addToQueue(self, task):
            #add to queue
            win.q.put(task, timeout=1000)

            #update UI
            wid1 = QtGui.QTreeWidgetItem()
            wid1.setText(0, str(task))
            win.queTree.addTopLevelItem(wid1)

        def run(self, debug=1):
            print 'Starting Task Server @' + socket.gethostbyname(socket.gethostname()) + ':' + str(self.port)
            while self.running:
                client_socket, address = self.server_socket.accept()
                ip = str(address[0])
                data = client_socket.recv(512)
                if 'runTask' in data:
                    taskDict = eval(data.split(' >> ')[-1])
                    print 'SERVER>> Received task:', str(taskDict)
                    self.addToQueue(taskDict)

    class TaskQueueServer(threading.Thread):
        def __init__(self):
            q = self.q_in
            while True:
                if self.q_in:
                    worker = win.findLocalWorker()
                    if worker:
                        taskDict = self.q_in[0]
                        worker.task = taskDict
                        worker.startTask()
                        self.q_in.pop[0]


    def startJobServer(self, port):
        self.mainJobServer = self.JobServer(port)
        self.mainJobServer.start()

    def startQueue(self):
        self.manager = mp.Manager()
        self.q = self.manager.Queue()


if __name__ == "__main__":
    app = QtGui.QApplication(sys.argv)
    win = MayaTaskServer()
    win.show()
    sys.exit(app.exec_())

Answer 1

所以，我是怎么做到的。一个非常简单，务实的解决方案。

我有一个名为＆＃39; finaLocalWorker＆＃39;的方法，您可以看到工人类可以被标记为“忙碌”。如果工作人员不忙，则会向其发送传入任务。

如果所有工作人员都很忙，那么传入的任务会被添加到一个名为“self.q＆＃39;”的简单列表中。

当一个worker完成一个任务时，mpPool.apply_async有一个触发taskComplete方法的回调。这个方法说“如果是self.q”，则取出列表中的[0]项并弹出（删除）它。否则就把自己标记为不忙......

这允许将一批500个动画之类的传入请求溢出到任务列表中排队，但服务器仍然能够在一段时间内不接收任务并立即处理任何进入的任务。

我将最终代码放在github上。

具有任务队列的多线程python（mp.Pool）服务器

1 个答案: