proceso de Python, hilo, corrutina

proceso

Un proceso es un programa en ejecución. Cada proceso tiene su propio espacio de direcciones, memoria, pila de datos y otros datos auxiliares que se utilizan para rastrear la ejecución. En un multiproceso en un sistema de CPU de un solo núcleo, puede haber muchos programas en la memoria, pero solo un programa se está ejecutando en un momento dado; es decir, es posible que el proceso A se esté ejecutando en un segundo y el proceso B se ejecuta en el siguiente segundo, aunque Ambos están en la memoria y ninguno se está ejecutando realmente al mismo tiempo.
El proceso es la unidad más pequeña de asignación de recursos del sistema; el proceso tiene su propio espacio de memoria independiente (los datos no se comparten, sobrecarga alta)
1. Utilice el proceso para lograr múltiples procesos

from multiprocessing import Process, Pool

def do_work():
    print('进程正在执行, 进程ID: {}'.format(Process.pid))

if __name__ == '__main__':
    p = Process(target=do_work)
    p2 = Process(target=do_work)
    p.start()
    p2.start()
    p.join()
    p2.join()

Dos. Utilice la agrupación de procesos para lograr procesos múltiples

from multiprocessing import Process, Pool

def do_work():
    print('进程正在执行, 进程ID: {}'.format(Process.pid))

if __name__ == '__main__':
    pool = Pool(processes=2)
    for i in range(0, 2):
        pool.apply_async(do_work)
    pool.close()
    pool.join()

Tres. La biblioteca estándar ProcessPoolExecutor del grupo de procesos después de python3.2

from concurrent.futures import ProcessPoolExecutor
from time import  sleep


def loop(nloop, nsec):
    print("start process", nloop)
    sleep(nsec)
    print("end process", nloop)


if __name__=="__main__":
    with ProcessPoolExecutor(max_workers=3) as executor:
        all_task = [executor.submit(loop, i, j) for i, j in zip([1, 2], [4, 3])]

Hilo

El hilo es la unidad más pequeña de ejecución de programación, subordinada al proceso y el ejecutor real del programa. Un proceso contiene al menos un subproceso principal y también puede tener más subprocesos secundarios. Python puede ejecutar múltiples subprocesos, pero al igual que el multiproceso de CPU de un solo núcleo, solo se ejecutará un subproceso en un momento dado.
Varios subprocesos comparten memoria (intercambio de datos, variables globales compartidas) para mejorar la eficiencia de la operación del programa
1. Utilice subprocesos para crear varios subprocesos

from threading import Thread
from time import sleep


def do_work(params):
    print('start Thread {}'.format(params))
    sleep(5)
    print('end Thread {}'.format(params))


if __name__ == '__main__':
    th = Thread(target=do_work, args=('th', ))
    th2 = Thread(target=do_work, args=('th2', ))
    th.start()
    th2.start()
    th.join()
    th2.join()

2. Utilice el grupo de subprocesos para crear varios subprocesos

from concurrent.futures import ThreadPoolExecutor


def do_work(params):
    print('start Thread {}'.format(params))
    sleep(5)
    print('end Thread {}'.format(params))

if __name__ == '__main__':
    with ThreadPoolExecutor(max_workers=3) as executor:
        all_task = [executor.submit(do_work, i) for i in range(1, 3)]

Coroutine

Coroutine: un hilo ligero en modo usuario, la programación de la colaboración está completamente controlada por el usuario; es una existencia más ligera que los hilos. Así como un proceso puede tener varios subprocesos, un subproceso también puede tener varias corrutinas. Lo más importante, corrutina no será gestionado por el núcleo del sistema operativo, y está completamente controlada por el programa
corrutina tiene su propio contexto registro y pilas;
cuando se co-rutina programada de entrega, excepto el contexto registro y la pila a otra ubicación;
de corte cuando vuelvas, restaurar el contexto de registro y la pila previamente guardados;
manipular directamente la pila sin la sobrecarga de las operaciones del kernel, acceder a variables globales sin bloqueos y cambiar de contexto rápidamente;
one.gevent implementa una corrutina

import gevent


def eat(name):
    print('%s eat 1' %name)
    gevent.sleep(2)
    print('%s eat 2' %name)


def play(name):
    print('%s play 1' %name)
    gevent.sleep(1)
    print('%s play 2' %name)


if __name__ == '__main__':
    
    g1 = gevent.spawn(eat, 'egon')
    g2 = gevent.spawn(play, name='egon')
    g1.join()
    g2.join()