共享在Python多处理中实时更新的数据

Question

我试图帮助某人做作业。目的是尝试进行多个程序，并帮助他们优化它。由于这些函数通过不断地实时修改的数据修改工作，因此他认为制作变量会有所帮助，但是由于多处理的工作方式，它并没有进行多处理。

问题是我对共享内存多处理不了解。我知道地图池的内容如何创建过程以及所有这些，但是使它们更新并同时依赖相同的信息对我来说有点棘手。我已经知道我需要做什么以及将为代码编写的优化。我只想知道如何解决这个特定问题以及其中的任何建议。

编辑以进行一些澄清和TLDR（也稍微删除代码）：

代码摘要： 因此，问题是该算法的作用如下：

1. 以下数字
2. 通过质量数列表进行分解n，直到
3. 每次prime检查n，如果n分为n
4. ，则计算出n，请计数多少次，并添加在保存该部门的总结果的因素列表中
5. ，将质数的目标重置为迭代，以直到该部门结果的SQRT

，这是困难的部分，我该如何使其这样这些信息在所有多过程中都可以准确地更新？

# PRIME FACTORIZATION
import time
import numpy as np
import math


def in_time_target_updater(new_divisor):
    global last_divisor
    global new_upto_target
    global full_number_target

    full_number_target = new_divisor
    last_divisor = new_divisor
    new_upto_target = math.sqrt(new_divisor)

def exponent_finder(num, input_target):
    """Finds how many times a prime goes into a number. For each time the number divides into a int it appends
    the number into the factors list. Once that is done it returns the last divisor in order to do updates.
    """
    global factor_list
    other_divisor = input_target
    for i in range(max_range):
        local_target = input_target//(num**(i+1))
        if other_divisor % num == 0:
            factor_list = np.append(factor_list, num)
            other_divisor = local_target
            continue
        else:
            return other_divisor

def phase1_list_iterator(list_or_queue):
    global found
    for value in list_or_queue:
        just_in_time_iteration(value)
        if found:
            break

def just_in_time_iteration(value):
    global found
    global factor_list

    if value > new_upto_target:

        found = True
        factor_list = np.append(factor_list, last_divisor)
        return found
    else:
        if full_number_target % value == 0:
            remaining_divisor = exponent_finder(value, full_number_target)
            in_time_target_updater(remaining_divisor)

def phase1():
    global factor_list
    phase1_list_iterator(prime_array)
    if found is True:
        if factor_list[-1] == 1:
            factor_list = factor_list[:-1]
        if factor_list[0] == 0:
            factor_list = np.array([num_to_factorize])
        return
    else:
         phase2()

def main_single_thread_comparative(input_):
    global num_to_factorize
    global max_range
    global og_target
    global new_upto_target
    global full_number_target
    global last_divisor
    global factor_list
    global prime_array
    global found
    global step_constant

    num_to_factorize = input_
    max_range = 200
    og_target = math.sqrt(num_to_factorize)
    new_upto_target = og_target
    full_number_target = num_to_factorize
    last_divisor = 0
    factor_list = np.empty(0, dtype=int)
    prime_array = np.load('prime_10000.npy')
    found = False
    step_constant = 2


    phase1()