A configuração

Eu escrevi um software bastante complexo em Python (em um PC com Windows). Meu software inicia basicamente duas conchas de intérpretes Python. O primeiro shell inicia (suponho) quando você clica duas vezes nomain.py Arquivo. Dentro desse shell, outros threads são iniciados da seguinte maneira:

    # Start TCP_thread
    TCP_thread = threading.Thread(name = 'TCP_loop', target = TCP_loop, args = (TCPsock,))
    TCP_thread.start()

    # Start UDP_thread
    UDP_thread = threading.Thread(name = 'UDP_loop', target = UDP_loop, args = (UDPsock,))
    TCP_thread.start()

oMain_thread inicia umTCP_thread e umUDP_thread. Embora esses sejam threads separados, todos eles são executados em um único shell Python.

oMain_threadtambém inicia um subprocesso. Isso é feito da seguinte maneira:

p = subprocess.Popen(['python', mySubprocessPath], shell=True)

Na documentação do Python, entendo que esse subprocesso está sendo executadosimultaneamente (!) em uma sessão / shell de interpretador Python separada. oMain_threadneste subprocesso é completamente dedicado à minha GUI. A GUI inicia umTCP_thread por todas as suas comunicações.

Eu sei que as coisas ficam um pouco complicadas. Portanto, resumi toda a instalação nesta figura:

Eu tenho várias perguntas sobre esta configuração. Vou listá-los aqui em baixo:

Questão 1 [Resolvido]

É verdade que um intérprete Python usa apenas um núcleo de CPU por vez para executar todos os threads? Em outras palavras, oPython interpreter session 1 (da figura) execute todos os 3 threads (Main_thread, TCP_thread eUDP_thread) em um núcleo da CPU?

Resposta: sim, isso é verdade. O GIL (Global Interpreter Lock) garante que todos os threads sejam executados em um núcleo de CPU por vez.

Questão 2 [Ainda não resolvido]

Tenho uma maneira de rastrear qual é o núcleo da CPU?

Questão 3 [Parcialmente resolvido]

Para esta pergunta, esquecemostópicos, mas nos concentramos nosubprocesso mecanismo em Python. Iniciar um novo subprocesso implica iniciar um novo intérprete Pythoninstância. Isso está correto?

Resposta: Sim, isso está correto. No início, houve alguma confusão sobre se o código a seguir criaria uma nova instância do interpretador Python:

    p = subprocess.Popen(['python', mySubprocessPath], shell = True)

A questão foi esclarecida. Esse código realmente inicia uma nova instância do interpretador Python.

O Python será inteligente o suficiente para fazer com que a instância separada do interpretador Python seja executada em um núcleo de CPU diferente? Existe uma maneira de rastrear qual, talvez com algumas declarações de impressão esporádicas também?

Pergunta 4 [Nova pergunta]

A discussão da comunidade levantou uma nova questão. Aparentemente, existem duas abordagens ao gerar um novo processo (dentro de uma nova instância do interpretador Python):

    # Approach 1(a)
    p = subprocess.Popen(['python', mySubprocessPath], shell = True)

    # Approach 1(b) (J.F. Sebastian)
    p = subprocess.Popen([sys.executable, mySubprocessPath])

    # Approach 2
    p = multiprocessing.Process(target=foo, args=(q,))

A segunda abordagem tem a desvantagem óbvia de ter como alvo apenas uma função - enquanto eu preciso abrir um novo script Python. Enfim, as duas abordagens são semelhantes no que alcançam?