线程、进程、锁、GIL 与任务池：按任务类型选择并发模型

from concurrent.futures import ProcessPoolExecutor, ThreadPoolExecutor
from time import perf_counter, sleep


def simulated_io(value: int) -> int:
    sleep(0.2)
    return value * 2


def cpu_work(limit: int) -> int:
    return sum(number * number for number in range(limit))


def run_pool(pool_type, function, values):
    started = perf_counter()
    with pool_type(max_workers=4) as pool:
        result = list(pool.map(function, values))
    return result, perf_counter() - started


def main() -> None:
    io_result, io_seconds = run_pool(ThreadPoolExecutor, simulated_io, range(8))
    cpu_result, cpu_seconds = run_pool(
        ProcessPoolExecutor, cpu_work, [1_000_000] * 4
    )
    print(io_result, round(io_seconds, 2))
    print(len(cpu_result), round(cpu_seconds, 2))


if __name__ == "__main__":
    main()

from threading import Lock, Thread
from time import sleep

lock = Lock()
counter = 0


def increase() -> None:
    global counter
    for _ in range(100):
        with lock:
            current = counter
            sleep(0.0001)
            counter = current + 1


threads = [Thread(target=increase) for _ in range(4)]
for thread in threads:
    thread.start()
for thread in threads:
    thread.join()

print(counter)

from multiprocessing import Process, Queue


def calculate(value: int, output: Queue) -> None:
    output.put((value, value * value))


if __name__ == "__main__":
    output = Queue()
    processes = [Process(target=calculate, args=(value, output)) for value in range(3)]
    for process in processes:
        process.start()
    results = [output.get() for _ in processes]
    for process in processes:
        process.join()
    print(sorted(results))