将变量更新为多处理python

我使用2个python进程，我想知道如何共享和更新变量。 我设法将变量发送到进程，但该变量在进程中不会更新

在我的代码中，当进程

worker

启动时，它每3秒增加变量

a

。 同时，进程

my_service

连续显示

a

的值

#!/usr/bin/python
# -*- coding: utf-8 -*-

#import multiprocessing as mp
#from multiprocessing import Process
import multiprocessing

import time
from globalvar import *
a=8
#toto=8

def worker():
    name = multiprocessing.current_process().name
    # print (name,"Starting")
    # time.sleep(2)
    # print (name, "Exiting")
    for a in range(1,4):
        print ("worker=",a)
        time.sleep(3)

def my_service(az):
    name = multiprocessing.current_process().name
    # print (name,"Starting")
    # time.sleep(3)
    # print (name, "Exiting")
    while True:
        print ("my_service=",az)
        time.sleep(2)

if __name__ == '__main__':
    #Process(target=worker).start()
    service = multiprocessing.Process(name='my_service', target=my_service,args=(a,))
    worker_1 = multiprocessing.Process(name='worker 1', target=worker)
    worker_2 = multiprocessing.Process(target=worker) # use default name

    worker_1.start()
    worker_2.start()
    service.start()

但结果并不是我所期望的：

worker= 1
worker= 1
my_service= 8
my_service= 8
worker= 2
worker= 2
my_service= 8
worker= 3
worker= 3
my_service= 8

进入

worker

的变量增加，但在流程

service

那么，如何在进程之间共享更新的变量呢

---

Thx，

使用python进行多处理的问题是，任何进程都是完全独立于其他进程的。启动时，它复制当前变量，然后处理此副本：这意味着对变量状态的任何修改都不会复制到其他进程。 这是由Python的全局解释器锁造成的，它确保只有一个进程可以同时访问一个变量，以避免损坏内存。您可以在此处看到更多信息：

现在，对于您的特定问题，您可以使用共享变量

from multiprocessing import Value
a=Value('f', 0.0) # create a shared float, initialised at 0
a.value # read the value
a.value=50 # modify the value

您需要声明

a

，并将其作为每个进程的参数传递

但当您“绕过”GIL时，您需要管理自己对该变量的访问，以避免两个进程同时尝试读取/修改它。这就是为什么每个共享变量都带有一个

锁

，允许访问该变量

a.acquire() #acquire the Lock, forbidding access to other processes.
a.value # read the value
a.value=50 # modify the value
a.release() # don't forget to release the lock, or else you will block everything.

请注意，在发生错误/异常的情况下，如果不释放锁，对变量的访问将永远丢失。如果这是一个问题，请添加以下内容：

try:
    a.acquire() #acquire the Lock, forbidding access to other processes.
    a.value # read the value
    a.value=50 # modify the value
    a.release() # don't forget to release the lock, or else you will block everything.
except Exception as e:
    print e
    a.release()

您的最终代码：

#!/usr/bin/python
# -*- coding: utf-8 -*-

import multiprocessing
from multiprocessing import Value

import time
#from globalvar import *
a=Value('f', 8)
#toto=8

def worker(a):
    try:
        name = multiprocessing.current_process().name
        for i in range(1,4):
            a.acquire()
            a.value=i
            a.release()
            print ("worker=",a.value)
            time.sleep(3)
    except Exception as e:
        print e
        a.release()

def my_service(az):
    name = multiprocessing.current_process().name
    # print (name,"Starting")
    # time.sleep(3)
    # print (name, "Exiting")
    while True:
        try:
            az.acquire()
            print ("my_service=",az.value)
            az.release()
            time.sleep(2)
        except Exception as e:
            print e
            az.release()

if __name__ == '__main__':
    #Process(target=worker).start()
    service = multiprocessing.Process(name='my_service', target=my_service,args=(a,))
    worker_1 = multiprocessing.Process(name='worker 1', target=worker,args=(a,))
    worker_2 = multiprocessing.Process(target=worker,args=(a,)) # use default name

    worker_1.start()
    worker_2.start()
    service.start()

---

工作人员中的a和服务中的a在完全不同的范围内，因此根本不相关，也不会相互更新。即使你没有做这个多进程，你也不会看到它们相互修改。好的，但是有一个解决方案可以在进程之间更新变量？因为它是多进程的，而不是多线程的，我相信它们变量不会在进程之间共享。您可以让每个进程执行其工作，然后将更新后的值返回到主全局进程。您可能希望研究使用多进程的共享内存功能，如：那么，您认为可以通过多线程共享更新后的数据吗？