最近很多小伙伴都在问在python多处理中修改对象和python中可以修改的对象这两个问题，那么本篇文章就来给大家详细解答一下，同时本文还将给你拓展Flask中的Python多处理、python多处理

最近很多小伙伴都在问在python多处理中修改对象和python中可以修改的对象这两个问题，那么本篇文章就来给大家详细解答一下，同时本文还将给你拓展Flask中的Python多处理、python多处理中的共享变量不起作用、python多处理产量量子、Python多处理传递引用等相关知识，下面开始了哦！

• 在python多处理中修改对象（python中可以修改的对象）
• Flask中的Python多处理
• python多处理中的共享变量不起作用
• python多处理产量量子
• Python多处理传递引用

在python多处理中修改对象（python中可以修改的对象）

我有很多自定义对象，需要对其执行独立（可并行化）的任务，包括修改对象参数。我试过同时使用Manager（）。dict和’sharedmem’ory，但都没有用。例如：

import numpy as npimport multiprocessing as mpimport sharedmem as shmclass Tester:    num = 0.0    name = ''none''    def __init__(self,tnum=num, tname=name):        self.num  = tnum        self.name = tname    def __str__(self):        return ''%f %s'' % (self.num, self.name)def mod(test, nn):    test.num = np.random.randn()    test.name = nnif __name__ == ''__main__'':    num = 10    tests = np.empty(num, dtype=object)    for it in range(num):        tests[it] = Tester(tnum=it*1.0)    sh_tests = shm.empty(num, dtype=object)    for it in range(num):        sh_tests[it] = tests[it]        print sh_tests[it]    print ''\n''    workers = [ mp.Process(target=mod, args=(test, ''some'') ) for test in sh_tests ]    for work in workers: work.start()    for work in workers: work.join()    for test in sh_tests: print test

打印出：

0.000000 none1.000000 none2.000000 none3.000000 none4.000000 none5.000000 none6.000000 none7.000000 none8.000000 none9.000000 none0.000000 none1.000000 none2.000000 none3.000000 none4.000000 none5.000000 none6.000000 none7.000000 none8.000000 none9.000000 none

即对象没有被修改。

如何实现所需的行为？

答案1

问题在于，当将对象传递给工作进程时，它们会被泡菜包装，运送到另一个过程中，然后在其中解压缩并进行处理。您的对象没有像克隆的那样传递给其他过程。您不返回对象，因此克隆的对象被愉快地修改，然后被丢弃。

看起来这是无法完成的（Python：可以在两个单独的进程之间共享内存中的数据）。

您可以做的就是返回修改后的对象。

import numpy as npimport multiprocessing as mpclass Tester:    num = 0.0    name = ''none''    def __init__(self,tnum=num, tname=name):        self.num  = tnum        self.name = tname    def __str__(self):        return ''%f %s'' % (self.num, self.name)def mod(test, nn, out_queue):    print test.num    test.num = np.random.randn()    print test.num    test.name = nn    out_queue.put(test)if __name__ == ''__main__'':           num = 10    out_queue = mp.Queue()    tests = np.empty(num, dtype=object)    for it in range(num):        tests[it] = Tester(tnum=it*1.0)    print ''\n''    workers = [ mp.Process(target=mod, args=(test, ''some'', out_queue) ) for test in tests ]    for work in workers: work.start()    for work in workers: work.join()    res_lst = []    for j in range(len(workers)):        res_lst.append(out_queue.get())    for test in res_lst: print test

这的确引起了一个有趣的观察，因为产生的过程是相同的，所以对于随机数它们都以相同的种子开始，因此它们 都 产生相同的“随机”数。

Flask中的Python多处理

这个问题可能已经有人提出过，而且回答的可能性更大，但是我不知道在哪里可以找到它。

问题：我有一个用于pythonflask的路由器，该路由器需要花费一些时间来处理每个调用的数据。我需要使对路由的每个调用本身就是一个线程，因此它不必等待请求被加载。

答案1

Flask带有内置的开发Web服务器，但是你不应该在生产环境中使用它。

为了获得一些很酷的功能，例如为每个请求和静态文件服务提供单独的进程，你需要在Flask应用程序前面运行实际的Web服务和WSGI服务。

该Flask文档提供了一些有关如何进行设置的示例。流行的Web Server / WSGI组合是Apache / mod_wsgi和Nginx / Gunicorn，但是还有许多其他选择。

python多处理中的共享变量不起作用

import multiprocessing
import ctypes
import time


def function1():
    global value

    while True:
        value.value += 1
        time.sleep(1)


def function2():
    global value

    while True:
        value.value += 1
        time.sleep(1)


if __name__ == "__main__":
    manager = multiprocessing.Manager()
    value = manager.Value("i",0)

    process1 = multiprocessing.Process(target=function1)
    process2 = multiprocessing.Process(target=function2)
    process1.start()
    process2.start()

    while True:
        print(value.value)
        time.sleep(1)

NameError: name ''value'' is not defined

from multiprocessing.managers import BaseManager
from Queue import Queue


class KeyHandler(Queue):

    def __init__(self,elements=[]):
        Queue.__init__(self)

        for element in elements:
            self.put(element)

    def __iter__(self):
        return iter(self.get,object())

    def __call__(self):
        return self


class QueueManager(BaseManager):
    pass

keyhandler = KeyHandler(range(10))


QueueManager.register(''keyhandler'',callable=keyhandler)
manager = QueueManager(address=('''',50000),authkey=''foobar'')
server  = manager.get_server()
server.serve_forever()

from multiprocessing.managers import BaseManager


class QueueManager(BaseManager):
    pass


QueueManager.register(''keyhandler'')
manager = QueueManager(address=('''',authkey=''foobar'')
manager.connect()

keyhandler = manager.keyhandler()

for elem in keyhandler:
    print elem

Traceback (most recent call last):
  File "client2.py",line 14,in <module>
    for elem in keyhandler:
TypeError: ''Autoproxy[keyhandler]'' object is not iterable

class KeyHandlerProxy(BaseProxy):
    _exposed_ = (''next'',''get'')

    def __iter__(self):
        return self

    def next(self):
        o = self._callmethod(''get'')
        if object() == o:
            raise stopiteration
        return o

QueueManager.register(''keyhandler'',proxytype=KeyHandlerProxy)