Question

我最近开始使用Python的多线程和多处理功能。

我尝试编写使用生产者/消费者方法从JSON日志文件中读取块的代码，将这些块作为事件写入队列，然后启动一组将从该队列中轮询事件的进程（文件块）并处理每一个，打印出结果。

我的目的是首先启动进程，让他们等待事件开始进入队列。

我目前正在使用这个代码，这似乎有用，我发现了一些例子：

import re, sys
from multiprocessing import Process, Queue

def process(file, chunk):
    f = open(file, "rb")
    f.seek(chunk[0])
    for entry in pat.findall(f.read(chunk[1])):
        print(entry)

def getchunks(file, size=1024*1024):
    f = open(file, "rb")
    while True:
        start = f.tell()
        f.seek(size, 1)
        s = f.readline() # skip forward to next line ending
        yield start, f.tell() - start
        if not s:
            break

def processingChunks(queue):
    while True:
        queueEvent = queue.get()
        if (queueEvent == None):
            queue.put(None)
            break
        process(queueEvent[0], queueEvent[1])

if __name__ == "__main__":
    testFile = "testFile.json"
    pat = re.compile(r".*?\n")
    queue = Queue()

    for w in xrange(6):
        p = Process(target=processingChunks, args=(queue,))
        p.start()

    for chunk in getchunks(testFile):
        queue.put((testFile, chunk))
        print(queue.qsize())
    queue.put(None)

但是，我想学习如何使用concurrent.futures ProcessPoolExecutor以异步方式使用Future结果对象来实现相同的结果。

我的第一次尝试暗示使用由多处理管理器创建的外部队列，我将传递给轮询进程。

然而，这似乎不起作用，我认为这可能不是ProcessPoolExecutor设计工作的方式，因为它似乎使用它自己的内部队列。

我使用了这段代码：

import concurrent
from concurrent.futures import as_completed
import re, sys
from multiprocessing import Lock, Process, Queue, current_process, Pool, Manager

def process(file, chunk):
    entries = []
    f = open(file, "rb")
    f.seek(chunk[0])
    for entry in pat.findall(f.read(chunk[1])):
        entries.append(entry)
        return entries

def getchunks(file, size=1024*1024):
    f = open(file, "rb")
    while True:
        start = f.tell()
        f.seek(size, 1)
        s = f.readline() # skip forward to next line ending
        yield start, f.tell() - start
        if not s:
            break

def processingChunks(queue):
    while True:
        queueEvent = queue.get()
        if (queueEvent == None):
            queue.put(None)
            break
        return process(queueEvent[0], queueEvent[1])

if __name__ == "__main__":
    testFile = "testFile.json"
    pat = re.compile(r".*?\n")
    procManager = Manager()
    queue = procManager.Queue()

    with concurrent.futures.ProcessPoolExecutor(max_workers = 6) as executor:
        futureResults = []
        for i in range(6):
            future_result = executor.submit(processingChunks, queue)
            futureResults.append(future_result)

        for complete in as_completed(futureResults):
            res = complete.result()
            for i in res:
                print(i)


    for chunk in getchunks(testFile):
        queue.put((testFile, chunk))
        print(queue.qsize())
    queue.put(None)

我无法用这个获得任何结果，所以显然我做错了什么，并且有一些我不理解的概念。

请问你能帮我解释一下如何实现这个目标吗？

Answer 1

如果您使用ProcessPoolExecutor，则根本不需要processingChunks功能，或者您从{{1}导入的任何内容}。该池基本上完成了您的功能之前自动执行的操作。相反，使用类似的东西排队并一次性调度所有工作：

multiprocessing

我不确定您的原始代码如何使用with concurrent.futures.ProcessPoolExecutor(max_workers = 6) as executor: executor.map(process, itertools.repeat(testFile), getchunks(testFile))而不是pat的参数（我预计每个工作进程都会失败{{1}例外）。如果这是一个真正的问题（而不仅仅是您的示例代码的工件），您可能需要更多地修改内容以将其与process和NameError一起传递给工作进程（file可能会派上用场。）

Answer 2

感谢Blckknght，他的回复让我朝着正确的方向前进。这是我最初问题的可能解决方案：

#!/usr/bin/python
import concurrent
from concurrent.futures import as_completed
import re, sys

def process(event):
    entries = []
    fl = event[0]
    chunk = event[1]
    pat = event[2]
    f = open(fl, "rb")
    f.seek(chunk[0])
    for entry in pat.findall(f.read(chunk[1])):
       entries.append(entry)
    return entries

def getchunks(file, pat, size=1024*1024):
    f = open(file, "rb")
    while True:
        start = f.tell()
        f.seek(size, 1)
        s = f.readline() # skip forward to next line ending
        yield (file, (start, f.tell() - start), pat)
        if not s:
            break

if __name__ == "__main__":
    testFile = "testFile.json"
    pat = re.compile(r".*?\n")
    results = []

    with concurrent.futures.ProcessPoolExecutor() as executor:
        for res in (executor.submit(process, event) for event in getchunks(testFile, pat)):
            results.append(res)

    for complete in as_completed(results):
        for entry in complete.result():
            print('Event result: %s' % entry)

Python：如何将外部队列与ProcessPoolExecutor一起使用？

2 个答案: