5

我有这样的情况：

主进程生成一些子进程，他们应该将结果写入字符串和数字类型的共享对象中，对于数字类型没有问题，但是对于字符串，值会丢失。

import multiprocessing as mp
from ctypes import Structure, c_double, c_wchar_p, c_int

# shared obj class
class SharedObj(Structure):
    _fields_ = [('name', c_wchar_p), ('val', c_double) ]

def run_mp( values , lock , s ) :
    for i in range( s , len( values ) , 2 ):
        lock.acquire()
        values[i].name = str( i ) # write the string value in the shared obj
        values[i].val = float( i )
        print( "tmp: %d" % i )
        lock.release()

def main():
    # creating the shared obj and mutex
    values = mp.Array(  SharedObj , [SharedObj() for i in range( 10 )] )
    lock_j = mp.Lock()

    # creating two sub-process form the function run_mp
    p1 = mp.Process( target=run_mp , args=( values , lock_j , 0 ))
    p2 = mp.Process( target=run_mp , args=( values , lock_j , 1 ))

    p1.start()
    p2.start()

    p1.join()
    p2.join()

    for v in  values:
        print()
        print( "res name: %s" % v.name )
        print( "res val: %f " % v.val )


if __name__ == '__main__':
    main()

结果共享对象中包含 c_double 的字段被写入到字段中，但子进程 rum-mp( string values[i].name = str( i )) 中生成的字符串会在主进程中丢失。

有一种方法可以保存子流程中生成的字符串吗？

此代码的输出如下所示：

主进程中生成的字符串是完全随机的。

tmp: 0
tmp: 2
tmp: 3
tmp: 4

res name: ����羍����羍
res val: 0.000000
res name: ����羍����羍
res val: 1.000000
res name:
res val: 2.000000   ....
4

2 回答 2

3

这是您的代码稍作修改的版本：

#!/usr/bin/env python

将多处理导入为 mp


def run_mp（值）：
    对于 c_arr，c_double 的值：
        c_arr.value = '你好 foo'
        c_double.value = 3.14

定义主（）：
    锁定 = mp.Lock()
    child_feed = []
    对于范围内的 i (10)：
        child_feed.append((
            mp.Array('c', 15, lock = lock),
            mp.Value('d', 1.0/3.0, lock = lock)
        ))

    p1 = mp.Process(target=run_mp, args=(child_feed,))
    p2 = mp.Process(target=run_mp, args=(child_feed,))

    p1.start()
    p2.start()

    p1.join()
    p2.join()

    对于 child_feed 中的 c_arr、c_double：
        打印（）
        print("资源名称: %s" % c_arr.value )
        print("res val: %f" % c_double.value)


如果 __name__ == '__main__'：
    主要的（）

看看http://docs.python.org/library/multiprocessing.html有一个使用 Array of chars 的例子。

还有一个 mmap 模块可以共享内存http://docs.python.org/library/mmap.html但是你必须通过信号量来同步访问自己。如果您喜欢更简单的方法，只需使用管道。

于 2012-09-09T21:23:41.057 回答
1

我不想使用multiprocessing.Array，因为需要提前指定其大小的明显要求。以下内容适用于我，而不是拥有一个兼容多处理的unicode对象。它使用 Python 2.6 进行了多进程测试。

>>> shared_str = multiprocessing.Manager().Value(unicode, 'some initial value')
>>> shared_str.value
'some initial value'
>>> shared_str.value = 'some new value'
>>> shared_str.value
'some new value'

为了解决作者关于共享字符串和数字的具体问题，也许可以创建一个可序列化的对象来存储这些对象并将其提供给Value。

您当然可以反对需要Manager为此目的使用。如果是这样，请提供替代解决方案。

于 2012-11-08T17:23:44.133 回答