Question

我有一个multiprocessing.manager.Array对象，将被多个工作人员共享以计算观察事件：数组中的每个元素都包含不同事件类型的计数。增加计数需要读取和写入操作，因此我认为为避免竞争条件，每个工作人员都需要请求一个涵盖两个阶段的锁定，例如

with lock:
    my_array[event_type_index] += 1

我的直觉是应该可以锁定特定的数组元素。使用这种类型的锁，worker＃1可以在worker＃2递增元素2的同时递增元素1.这对我的应用程序（ n -gram counting）特别有用，其中数组长度非常大，碰撞很少。

但是，我无法弄清楚如何为数组请求元素锁定。 multiprocessing中是否存在此类问题，还是有解决方法？

有关更多背景信息，我在下面列出了我当前的实现：

import multiprocessing as mp
from queue import Empty

def count_ngrams_in_sentence(n, ngram_counts, char_to_idx_dict, sentence_queue, lock):
    while True:
        try:
            my_sentence_str = sentence_queue.get_nowait()
            my_sentence_indices = [char_to_idx_dict[i] for i in my_sentence_str]
            my_n = n.value
            for i in range(len(my_sentence_indices) - my_n + 1):
                my_index = int(sum([my_sentence_indices[i+j]*(27**(my_n - j - 1)) \
                                    for j in range(my_n)]))
                with lock:  # lock the whole array?
                    ngram_counts[my_index] += 1
            sentence_queue.task_done()
        except Empty:
            break
    return

if __name__ == '__main__':
    n = 4
    num_ngrams = 27**n
    num_workers = 2
    sentences = [ ... list of sentences in lowercase ASCII + spaces ... ]

    manager = mp.Manager()
    sentence_queue = manager.JoinableQueue()
    for sentence in sentences:
        sentence_queue.put(sentence)
    n = manager.Value('i', value=n, lock=False)
    char_to_idx_dict = manager.dict([(i,ord(i)-97) for i in string.ascii_lowercase] + [(' ', 26)],
                                    lock=False)
    lock = manager.Lock()
    ngram_counts = manager.Array('l', [0]*num_ngrams, lock=lock)
''
    workers = [mp.Process(target=count_ngrams_in_sentence,
                          args=[n,
                                ngram_counts,
                                char_to_idx_dict,
                                sentence_queue,
                                lock]) for i in range(num_workers)]
    for worker in workers:
        worker.start()
    sentence_queue.join()

Answer 1

Multiprocessing.manager.Array带有内置锁。要切换到RawArray。

具有锁列表。修改索引之前，请获取阵列的锁。然后释放。

locks[i].acquire()
array[i,:]=0
locks[i].release()

正如我所说，如果数组是MultiProcessing.RawArray或类似的数组，则多个进程可以同时读取或写入。对于 some 类型的数组，对数组的读/写本质上是原子的-锁本质上是内置的。在继续之前请仔细研究。

关于性能，在Python中索引到列表的时间大约是纳秒级，而获取和释放的锁定级别大约是微秒级。这不是一个大问题。

如何在多处理包中锁定特定的数组索引？

1 个答案: