使用Python进行多处理，锁定变量

我想创建两个进程。他们每个人都在一张纸上写了10遍 长度为20的数组。两个进程访问相同的数组。 一个进程尽快写入，另一个进程必须等待一段时间才能写入

我的问题是，我不能锁定这些变量来防止竞争条件。 甚至在多核系统上也可以吗？ 我还想把数组填满。在此状态下，仅写入阵列的前十个插槽

这是我的密码：

from multiprocessing import Process, RawValue, RawArray, Value, Array, Lock
from ctypes import c_int

def write1(field):
    counter = 0
    global position
    for position in range(len(field)):
        if counter < 10:
            field[position] = 1
            counter += 1
            position += 1


def write2(field):
    counter = 0
    global position
    for position in range(len(field)):
        for i in range(40):
            if i == (40-1):
                if counter < 10:
                    field[position] = 2
                    counter += 1
                    position += 1

if __name__ == '__main__':
    field = Array(c_int, range(20), lock = True)
    position = Value(c_int, 0, lock = True)

    p1 = Process(target=write1,args=(field,))
    p2 = Process(target=write2,args=(field,))
    p2.start()
    p1.start()


    p1.join()
    p2.join()

    print(field[:])
    print('done')

来自多处理导入进程，RawValue，RawArray，Value，Array，Lock
从ctypes导入c_int
def write1（字段）：
计数器=0
全球地位
对于范围内的位置（透镜（场））：
如果计数器<10：
字段[位置]=1
计数器+=1
位置+=1
def write2（字段）：
计数器=0
全球地位
对于范围内的位置（透镜（场））：
对于范围（40）内的i：
如果i==（40-1）：
如果计数器<10：
字段[位置]=2
计数器+=1
位置+=1
如果uuuu name uuuuuu='\uuuuuuu main\uuuuuuu'：
字段=数组（c_int，范围（20），锁=真）
位置=值（c_int，0，lock=True）
p1=进程（目标=write1，参数=（字段，））
p2=进程（目标=write2，参数=（字段，））
p2.start（）
p1.开始（）
p1.join（）
p2.join（）
打印（字段[：]）
打印（‘完成’）

编辑

我找到了解决办法。我必须使用一个单独的锁定对象来锁定我的阵列

from multiprocessing import Process, RawValue, RawArray, Value, Array, Lock
from ctypes import c_int

def write1(field, lock):
    counter = 0
    global position
    with lock:
        for position in range(len(field)):
            if counter < 10:    
                field[position] = 1
                counter += 1

def write2(field, lock):
    counter = 0
    global position
    with lock:
        for position in range(len(field)):
            for i in range(40):
                if i == (40-1):
                    if counter < 10:
                        field[position] = 2
                        counter += 1

if __name__ == '__main__':
    lock = Lock()
    field = Array(c_int, range(20))
    position = Value(c_int, 0)

    p1 = Process(target=write1,args=(field,lock))
    p2 = Process(target=write2,args=(field,lock))
    p2.start() 
    p1.start()


    p1.join()
    p2.join()

    print(field[:])
    print('done')

来自多处理导入进程，RawValue，RawArray，Value，Array，Lock
从ctypes导入c_int
def write1（字段，锁定）：
计数器=0
全球地位
带锁：
对于范围内的位置（透镜（场））：
如果计数器<10：
字段[位置]=1
计数器+=1
def write2（字段，锁定）：
计数器=0
全球地位
带锁：
对于范围内的位置（透镜（场））：
对于范围（40）内的i：
如果i==（40-1）：
如果计数器<10：
字段[位置]=2
计数器+=1
如果uuuu name uuuuuu='\uuuuuuu main\uuuuuuu'：
lock=lock（）
字段=数组（c_int，范围（20））
位置=值（c_int，0）
p1=进程（目标=写入1，参数=（字段，锁））
p2=进程（目标=write2，参数=（字段，锁））
p2.start（）
p1.开始（）
p1.join（）
p2.join（）
打印（字段[：]）
打印（‘完成’）

---

但我仍然存在一个问题，即一个进程编写的内容，另一个进程将覆盖。

您的问题是什么？由于您已经在使用多处理模块的Array类，因此会自动防止竞争条件。当

计数器<10

更改为

计数器<20

时，会写入完整的数组。这也是我认为的，一个简单的数组就足够了。你可以看看我的编辑，我解决了。现在再谈另一个问题。如果我使用计数器<20，整个数组将只由一个进程写入20次。我的目标是每个进程每次写入10次。感谢更新。我不认为需要额外的锁，因为它应该由

SharedTypes

-模块自动处理。也许我误解了文档。