使用所有内核的主要代码可能看起来像这样：

if __name__ == '__main__':
    start_time = time.time()
    with multiprocessing.Pool() as pool:
        results = pool.map(fibonacci, range(0, n))

    result = results[-1]
    
    U = time.time() - start_time
    print("Elapsed time =", U)

请注意，这并不一定比单个过程更快。由于多处理的开销，它可能需要一些微调（特别是通过为map设置块大小）。

你只初始化了多处理池，但没有使用所有的cpu，甚至没有使用多处理，而是使用以下代码：

if __name__ == '__main__':
    start_time = time.time()
    pool = multiprocessing.Pool()

last_result = None
    n = 100
    results = []
    for i in range(0, n): 
        results.append(pool.apply_async(fibonacci, (i,)))
    
    pool.close()
    pool.join()

    U = time.time() - start_time
    print("Elapsed time =", U)

pool.apply_async()方法调用fibonacci()函数并行方法

准确地监控CPU使用情况可能很困难，尤其是在 * fibonacci（）* 函数的寿命很短的情况下。但是，如果您使用适当的多处理技术，您可以放心，您的系统的能力将得到充分利用。
下面是一些类似于OP的代码，它将充分利用可用的CPU：

from numpy import array, ndarray
from multiprocessing import Pool
from time import perf_counter
from os import cpu_count

N = 100

def get_cpu_count() -> int:
    if (count := cpu_count()) is not None:
        return count
    return 1

def fibonacci(n: int) -> ndarray:
    sequence = [0, 1]
    for _ in range(n-2):  
        sequence.append(sequence[-1]+sequence[-2])  
    return array(sequence)

def main() -> None:
    with Pool() as pool:
        pool.map_async(fibonacci, range(N), chunksize=max(1, N//get_cpu_count())).wait()

if __name__ == '__main__':
    start = perf_counter()
    main()
    end = perf_counter()
    print(f'Duration={end-start:.4f}s')

• • 输出：**

Duration=0.2697s

• • 注：**

块大小的计算在许多情况下是合理的，但不是所有情况