[python] 스레딩 모듈과 다중 처리 모듈의 차이점은 무엇입니까?

Python 문서 인용문

Process vs Threads 및 GIL에 대한 주요 Python 문서 인용문을 다음에서 강조했습니다. CPython의 GIL (Global Interpreter Lock)이란?

프로세스 대 스레드 실험

차이점을 더 구체적으로 보여주기 위해 약간의 벤치마킹을했습니다.

벤치 마크에서는 8 개의 하이퍼 스레드 CPU 에서 다양한 수의 스레드에 대해 CPU 및 IO 바인딩 작업을 시간을 정했습니다 . 스레드 당 제공되는 작업은 항상 동일하므로 스레드가 많을수록 전체 작업이 더 많이 공급됩니다.

결과는 다음과 같습니다.

데이터 플로팅 .

결론 :

• CPU 바운드 작업의 경우 다중 처리가 항상 더 빠릅니다. 아마도 GIL 때문일 것입니다.

• IO 바인딩 작업의 경우. 둘 다 정확히 같은 속도

• 스레드는 8 하이퍼 스레드 머신을 사용하고 있기 때문에 예상되는 8x 대신 약 4x까지만 확장됩니다.

  예상되는 8 배 속도 향상에 도달하는 C POSIX CPU 바인딩 작업과 대조됩니다. 시간 (1)의 출력에서 ​​’실제’, ‘사용자’및 ‘sys’는 무엇을 의미합니까?

  TODO : 그 이유를 모르겠습니다. 다른 Python 비 효율성이 작용해야합니다.

테스트 코드 :

#!/usr/bin/env python3

import multiprocessing
import threading
import time
import sys

def cpu_func(result, niters):
    '''
    A useless CPU bound function.
    '''
    for i in range(niters):
        result = (result * result * i + 2 * result * i * i + 3) % 10000000
    return result

class CpuThread(threading.Thread):
    def __init__(self, niters):
        super().__init__()
        self.niters = niters
        self.result = 1
    def run(self):
        self.result = cpu_func(self.result, self.niters)

class CpuProcess(multiprocessing.Process):
    def __init__(self, niters):
        super().__init__()
        self.niters = niters
        self.result = 1
    def run(self):
        self.result = cpu_func(self.result, self.niters)

class IoThread(threading.Thread):
    def __init__(self, sleep):
        super().__init__()
        self.sleep = sleep
        self.result = self.sleep
    def run(self):
        time.sleep(self.sleep)

class IoProcess(multiprocessing.Process):
    def __init__(self, sleep):
        super().__init__()
        self.sleep = sleep
        self.result = self.sleep
    def run(self):
        time.sleep(self.sleep)

if __name__ == '__main__':
    cpu_n_iters = int(sys.argv[1])
    sleep = 1
    cpu_count = multiprocessing.cpu_count()
    input_params = [
        (CpuThread, cpu_n_iters),
        (CpuProcess, cpu_n_iters),
        (IoThread, sleep),
        (IoProcess, sleep),
    ]
    header = ['nthreads']
    for thread_class, _ in input_params:
        header.append(thread_class.__name__)
    print(' '.join(header))
    for nthreads in range(1, 2 * cpu_count):
        results = [nthreads]
        for thread_class, work_size in input_params:
            start_time = time.time()
            threads = []
            for i in range(nthreads):
                thread = thread_class(work_size)
                threads.append(thread)
                thread.start()
            for i, thread in enumerate(threads):
                thread.join()
            results.append(time.time() - start_time)
        print(' '.join('{:.6e}'.format(result) for result in results))

GitHub 업스트림 + 동일한 디렉토리에 코드 플로팅 .

CPU : Intel Core i7-7820HQ CPU (4 코어 / 8 스레드), RAM : 2x Samsung M471A2K43BB1-CRC (2x 16GiB), SSD : Samsung MZVLB512HAJQ- 000L7 (3,000MB / s).

주어진 시간에 실행중인 스레드 시각화

이 게시물 https://rohanvarma.me/GIL/는 스레드가로 예정되어 때마다 콜백을 실행할 수 있음을 가르쳐 target=의 인수threading.Thread 및에 대해 동일한 multiprocessing.Process.

이를 통해 매번 실행되는 스레드를 정확하게 볼 수 있습니다. 이 작업이 완료되면 다음과 같은 내용이 표시됩니다 (이 특정 그래프를 만들었습니다).

            +--------------------------------------+
            + Active threads / processes           +
+-----------+--------------------------------------+
|Thread   1 |********     ************             |
|         2 |        *****            *************|
+-----------+--------------------------------------+
|Process  1 |***  ************** ******  ****      |
|         2 |** **** ****** ** ********* **********|
+-----------+--------------------------------------+
            + Time -->                             +
            +--------------------------------------+

다음과 같이 표시됩니다.

• 스레드는 GIL에 의해 완전히 직렬화됩니다.
• 프로세스가 병렬로 실행될 수 있습니다.