使用Unix系统的一个名为forking的功能，您可以从父进程读取(而不是写入)数据，开销为零。通常，您将不得不复制数据，但是在Unix中分叉一个进程允许您绕过这个问题。

使用此方法，池中的作业可以访问整个输入字符串并提取它将要处理的部分。然后，它可以单独拆分和解析字符串的这一部分，并返回其部分中整数的总和。from multiprocessing import Pool, cpu_count

from time import time

def serial(data):

return sum(map(int, data.split()))

def parallel(data):

processes = cpu_count()

with Pool(processes) as pool:

args = zip(

["input_"] * processes, # name of global to access

range(processes), # job number

[processes] * processes # total number of jobs

)

return sum(pool.map(job, args, chunksize=1))

def job(args):

global_name, job_number, total_jobs = args

data = globals()[global_name]

chunk = get_chunk(data, job_number, total_jobs)

return serial(chunk)

def get_chunk(string, job_number, total_jobs):

"""This function may mess up if the number of integers in each chunk is low (1-2).

It also assumes there is only 1 space separating integers."""

approx_chunk_size = len(string) // total_jobs

# initial estimates

start = approx_chunk_size * job_number

end = start + approx_chunk_size

if start and not string.startswith(" ", start - 1):

# if string[start] is not beginning of a number, advance to start of next number

start = string.index(" ", start) + 1

if job_number == total_jobs:

# last job

end = None

elif not string.startswith(" ", end - 1):

# if string[end] is part of a number, then advance to end of number

end = string.index(" ", end - 1)

return string[start:end]

def timeit(func, *args, **kwargs):

"Simple timing function"

start = time()

result = func(*args, **kwargs)

end = time()

print("{} took {} seconds".format(func.__name__, end - start))

return result

if __name__ == "__main__":

# from multiprocessing.dummy import Pool # uncomment this for testing

input_ = "1000000000 " * int(1e6)

actual = timeit(parallel, input_)

expected = timeit(serial, input_)

assert actual == expected