基于Python核心数动态生成优化型因数分解算法代码

核心思路 #

既然动态计算步长（如每个进程实时计算start和step）会带来解析开销，我们可以利用Python的代码生成能力，针对当前CPU核心数，直接生成对应数量的固定步长执行函数——每个函数的循环起始值和步长都是提前固化的字面量，避免运行时的动态计算开销，同时保留多进程并行能力。

实现方案 #

通过字符串拼接生成对应核心数的worker函数代码，再用exec将函数注入当前命名空间，最终让每个进程绑定一个固定步长的worker，完全复刻单线程固定步长的执行效率。

代码示例 #

假设你的核心计算逻辑是compute_D(target, B, n)（判断D是否为0）和get_factor(target, B, n)（获取分解出的因数），以下是完整实现：

import multiprocessing
import gmpy2

# 替换成你的核心计算逻辑
def compute_D(target, B, n):
    # 示例逻辑，实际替换为你的振荡计算代码
    return gmpy2.mod(target + B * n, 1000000)

def get_factor(target, B, n):
    # 示例逻辑，实际替换为你的因数提取代码
    return gmpy2.gcd(target, B + n)

def generate_fixed_step_workers(num_cores):
    worker_funcs = []
    # 为每个核心生成固定步长的worker函数代码
    for core_idx in range(num_cores):
        worker_code = f"""
def worker_{core_idx}(target, B, max_n, result_queue):
    # 固定步长：起始值为core_idx，步长为核心数num_cores
    for n in range({core_idx}, max_n, {num_cores}):
        D = compute_D(target, B, n)
        if D == 0:
            factor = get_factor(target, B, n)
            result_queue.put(factor)
            return
    result_queue.put(None)
"""
        # 执行代码，将函数加载到全局命名空间
        exec(worker_code, globals())
        worker_funcs.append(globals()[f"worker_{core_idx}"])
    return worker_funcs

def parallel_factorize(target, B, max_n):
    num_cores = multiprocessing.cpu_count()
    workers = generate_fixed_step_workers(num_cores)
    result_queue = multiprocessing.Queue()
    processes = []

    # 启动所有进程
    for worker in workers:
        p = multiprocessing.Process(
            target=worker,
            args=(target, B, max_n, result_queue)
        )
        processes.append(p)
        p.start()

    # 等待第一个有效结果（找到因数就终止所有进程）
    factor = result_queue.get()
    for p in processes:
        p.terminate()
        p.join()

    return factor if factor is not None else "未找到因数"

关键优势 #

1. 消除动态计算开销：每个worker的range参数是固化的字面量，Python解释器编译时即可完成解析，和单线程固定步长的执行效率一致。
2. 适配任意核心数：不管核心数是几个还是数千级，代码生成逻辑都能自动适配，无需手动编写大量重复代码。
3. 保留并行能力：每个进程独立处理自己的步长区间，一旦有进程找到因数就立即终止所有任务，避免无用计算。

注意事项 #

• 确保核心计算逻辑（compute_D、get_factor）是线程安全的，且能被multiprocessing正确序列化传递。
• 如果核心数极大，生成的函数数量会很多，但每个函数代码极简，内存占用可忽略，Python完全能够处理。
• 可以将生成的worker函数缓存起来，比如第一次生成后保存到全局变量，后续复用无需重复生成代码。

内容的提问来源于stack exchange，提问作者MYUN