Selección de la entrevista del rastreador de Python 02 episodios (proceso, experiencia del hilo)

Resumen de la experiencia del proceso de Python y la entrevista de subprocesos

portal del directorio de aprendizaje de Python

毕业季当下的你，还在为米那是烦恼吗？下面给大家带来Python进程线程的面试总结

Proceso, concepto de hilo

• Relación proceso e hilo
  

• 进程

  La ejecución única del programa en la computadora.

  El programa es un archivo ejecutable, que contiene el disco de forma estática.

  Un proceso es una descripción de proceso dinámico, que ocupa recursos operativos de la computadora y tiene un cierto ciclo de vida.

• El estado del proceso

  • Estado listo: el proceso tiene las condiciones de ejecución y espera a que la programación del sistema asigne los recursos de la CPU

  • Estado de ejecución: el proceso ocupa la CPU y se está ejecutando

  • Estado de espera: el proceso está bloqueado y en espera, y la CPU se liberará en este momento.

  • Cinco estados (agregando nuevos y terminación sobre la base de tres estados)

      新建 ： 创建一个进程，获取资源的过程
    
      终止 ： 进程结束，释放资源的过程
    

• 线程

  Los subprocesos se denominan procesos ligeros, que también son métodos de programación multitarea.

  También puede utilizar los recursos de varias CPU de la computadora

  Los subprocesos pueden entenderse como tareas de rama reabiertas en el proceso.

• Características del hilo

  1. Un proceso puede contener varios subprocesos

  2. El hilo también es un comportamiento en ejecución, que consume recursos de la computadora.

  3. Todos los hilos de un proceso comparten los recursos de este proceso.

  4. El funcionamiento de varios subprocesos tampoco afecta el funcionamiento de los demás.

  5. La creación y destrucción de subprocesos consume muchos menos recursos que los procesos.

• El proceso es la unidad más pequeña de asignación de recursos, el hilo es la unidad más pequeña de programación de la CPU

La diferencia entre hilos y procesos se puede resumir en los siguientes 4 puntos:

• Espacio de direcciones y otros recursos (como abrir archivos):

  Entre procesos 相互独立, el mismo proceso 各线程间资源共享.

  Los subprocesos de un proceso no son visibles en otros procesos.

• comunicación:

  IPC de comunicación entre procesos, los subprocesos pueden leer y escribir directamente los segmentos de datos del proceso (como las variables globales) para la sincronización del proceso de comunicación y se necesitan medios de exclusión mutua para garantizar la coherencia de los datos.

• Programación y conmutación:

  线程El cambio de contexto es más importante que el 进程cambio de contexto 快得多.

• En un sistema operativo multiproceso, un proceso no es una entidad ejecutable.

Comparación de multiproceso y multiproceso

Dimensión de contraste	multi-progreso	Multihilo	para resumir
Intercambio y sincronización de datos	Uso compartido de datos complejos y sincronización simple	El intercambio de datos es simple, la sincronización es complicada	Cada uno tiene sus propias ventajas y desventajas
Memoria, CPU	Ocupa memoria 多, conmutación compleja y utilización de CPU低	Ocupa memoria 少, conmutación simple, utilización de CPU高	Dominio del hilo
Crea, destruye, cambia	复杂，速度慢	简单，速度快	Dominio del hilo
Programación, depuración	Programación y depuración simples简单	Programación compleja, depuración复杂	Dominio del proceso
fiabilidad	Los procesos no se afectarán entre sí	Un hilo se cuelga hará que todo el proceso se cuelgue.	Dominio del proceso
repartido	Adecuado para múltiples núcleos, múltiples máquinas, fácil de expandir a múltiples máquinas	Adecuado para multi-core	Dominio del proceso

进程与线程总结

• El hilo baja en el proceso (un carro puro no puede correr)
• Un proceso puede contener varios subprocesos (un tren puede tener varios vagones)
• Es difícil compartir datos entre diferentes procesos (los pasajeros de un tren son difíciles de transferir a otro tren, como la transferencia de estación)
• Es fácil compartir datos entre diferentes subprocesos en el mismo proceso (el carro A es fácil de cambiar al carro B)
• Los procesos consumen más recursos informáticos que los subprocesos (varios trenes consumen más recursos que varios vagones)
• Los procesos no se afectarán entre sí. La caída de un hilo hará que todo el proceso se cuelgue (un tren no afectará al otro tren, pero si el vagón del medio de un tren está en llamas, afectará a todos los vagones del tren). tren.)
• El proceso se puede extender a varias máquinas, y el proceso es adecuado para múltiples núcleos como máximo (se pueden conducir diferentes trenes en múltiples vías y los vagones del mismo tren no pueden estar en diferentes vías)
• La dirección de memoria utilizada por el proceso se puede bloquear, es decir, cuando un hilo usa algo de memoria compartida, otros hilos deben esperar a que termine antes de usar esta memoria. (Como un baño en un tren) - "mutex"
• La dirección de memoria utilizada por el proceso puede limitar la cantidad de uso (por ejemplo, un restaurante en un tren, el número máximo de personas permitidas para entrar, si está lleno, debe esperar en la puerta y esperar a que alguien salga antes de que pueda entrar) - "semáforo"

Programación de procesos

• Módulo de uso: multiprocesamiento

• Proceso de creación

  1. Encapsular eventos que deben ser ejecutados por el nuevo proceso en funciones

  2. Cree objetos de proceso y asocie funciones a través de la clase de proceso del módulo

  3. La información y los atributos del proceso se pueden configurar a través del objeto de proceso

  4. Iniciar el proceso a través del inicio de la llamada al objeto de proceso

  5. Llamar a unirse a través del objeto de proceso para reclamar recursos del proceso

"""
multiprocessing

1.将需要新进程执行的事件封装为函数

2 .通过模块的Process类创建进程对象，关联函数

3 .通过进程对象调用start启动进程

4 .通过进程对象调用join回收进程资源
"""
import multiprocessing as mp
from time import  sleep

a = 1

# 进程函数
def fun():
    global a
    print("开始一个进程")
    sleep(2)
    a = 1000
    print("a = ",a)
    print("进程结束了，实际也没干啥")

if __name__ == '__main__':

    # 创建进程对象
    p = mp.Process(target=fun) # 绑定函数 此时还没有创建进程

    # start启动进程 自动执行fun函数，作为一个进程执行
    p.start()  # 此时进程才产生

    print("原有进程也干点事")
    sleep(3)
    print("原有进程其实也没干啥")

    # 回收进程
    p.join()

    print("a :",a) # a = 1

Programación de hilos

• Pasos de creación

  1. Heredar la clase Thread

  2. Anule el __init__método para agregar sus propias propiedades, use super () para cargar las propiedades de la clase principal

  3. Anular el método run ()

• Instrucciones

  1. Crear instancia de objeto

  2. Llame al inicio para ejecutar automáticamente el método de ejecución.

  3. Llamar a unirse para reciclar el hilo

"""
threading 创建线程演示
"""
from threading import Thread
from time import sleep
import os

a = 1  # 全局变量

# 线程函数
def music():
    for i in range(3):
        sleep(2)
        print(os.getpid(),"播放:黄河大合唱")

    global a
    print("a =",a)
    a = 1000

# 创建线程对象
t = Thread(target=music)
t.start() # 启动线程 执行music

for i in range(4):
    sleep(1)
    print(os.getpid(),"播放:葫芦娃")

t.join() # 回收线程资源

print("a:",a)"""
threading 创建线程演示
"""
from threading import Thread
from time import sleep
import os

a = 1  # 全局变量

# 线程函数
def music():
    for i in range(3):
        sleep(2)
        print(os.getpid(),"播放:黄河大合唱")

    global a
    print("a =",a)
    a = 1000

# 创建线程对象
t = Thread(target=music)
t.start() # 启动线程 执行music

for i in range(4):
    sleep(1)
    print(os.getpid(),"播放:葫芦娃")

t.join() # 回收线程资源

print("a:",a)

Zombis y huérfanos

• Proceso huérfano: el proceso padre sale antes que el proceso hijo, y el proceso hijo se convierte en un proceso huérfano en este momento. [Si pierde a sus padres, el padre se retirará primero]

  • Características: El proceso huérfano será adoptado por el proceso del sistema . En este momento, el proceso del sistema se convertirá en el nuevo proceso padre del proceso huérfano, y el proceso huérfano sale del proceso se procesará automáticamente.

• Proceso zombi: el proceso hijo sale antes que el proceso padre y el proceso padre no maneja el estado de salida del proceso hijo. En este momento, el proceso hijo se denomina proceso zombi.

  • Características: aunque el proceso zombie finaliza, algunos recursos de información del proceso permanecerán en la memoria y una gran cantidad de procesos zombie desperdiciarán los recursos de la memoria del sistema.

  • Cómo evitar los procesos zombies

    1. Use join () para reciclar
    2. Utilice el método de la señal en el proceso principal para tratar con [De una vez por todas, no disponible en la ventana]

"""
孤儿进程和僵尸进程演示
"""
from multiprocessing import Process
from time import sleep
import os
from signal import *
def fun():
    print("这是一个子进程",os.getppid(),'---',os.getpid())
    sleep(3)
    print("注定成为孤儿进程", os.getppid(), '---', os.getpid())
if __name__ == '__main__':
    signal(SIGCHLD,SIG_IGN) # 系统方法处理僵尸进程，所有子进程退出由系统处理
    p = Process(target=fun)
    p.start()
    p.join() # 防止僵尸产生
    # 大量工作进入死循环
    while True:
        pass

Punto muerto

• Deadlock se refiere a un fenómeno de bloqueo causado por la competencia por los recursos o por la comunicación entre dos o más hilos en el proceso de ejecución, si no hay fuerza externa, no podrán avanzar. En este momento, se dice que el sistema está en un estado de interbloqueo o que el sistema tiene un interbloqueo. [Causado por confusión lógica, varios bloqueos se bloquean entre sí, lo que hace que el programa no se ejecute]

• Condiciones de interbloqueo

  • Condición de exclusión mutua: se refiere al hilo que usa el método de exclusión mutua, cuando se usa un recurso, otros hilos no pueden usarlo. [El problema de que las tres partes se adeuden dinero se resolverá lógicamente]

  • Condiciones de solicitud y retención: se refiere al subproceso que ha retenido al menos un recurso, pero ha realizado una nueva solicitud de recurso y no liberará los recursos que tiene antes de adquirir los nuevos recursos.

  • Condiciones de no privación: no hay interferencia desde fuera del hilo, como que el sistema termine por la fuerza el hilo.

  • Condición de espera de bucle: cuando se produce un interbloqueo, debe haber un subproceso: una cadena circular de recursos, como T0 está esperando un recurso ocupado por T1; T1 está esperando un recurso ocupado por T2, ..., Tn está esperando para T0 Recursos ocupados.

• Cómo evitar el estancamiento

  • La lógica es clara y las cuatro condiciones causadas por el interbloqueo anterior no deben ocurrir al mismo tiempo.
  • Detección de interbloqueo por ingeniero de pruebas

Cerradura de intérprete global de GIL

• ¿Cuál es el problema de GIL (bloqueo de intérprete global) [el hilo de Python es insípido, no 8? 】

  Debido a que el bloqueo del intérprete se agrega al diseño del intérprete de Python , el intérprete de Python solo puede interpretar y ejecutar un hilo a la vez , lo que reduce en gran medida la eficiencia de ejecución del hilo.

• Esto lleva a consecuencias
  porque cuando un hilo encuentra un bloqueo, renunciará activamente al intérprete para explicar otros hilos. Por lo tanto, el subproceso múltiple de Python puede mejorar la eficiencia del programa al ejecutar tareas de bloqueo múltiple, y otras situaciones no pueden mejorar la eficiencia.

  [El subproceso múltiple mejora la eficiencia del subproceso múltiple a través del bloqueo de suspensión]

  [Consecuencia directa: solo se puede explicar un hilo al mismo tiempo]

  [Eficiencia: baja eficiencia al procesar tareas sin bloqueo]

  [Conclusión: los subprocesos de Python solo son adecuados para procesar tareas con alta latencia de bloqueo de manera eficiente]

• Sugerencias de problemas de GIL

* 尽量使用进程完成无阻塞的并发行为

* 不使用c作为解释器 （Java  C#）

 Guido的声明：<http://www.artima.com/forums/flat.jsp?forum=106&thread=214235>

• En conclusión
  • El problema de GIL no tiene nada que ver con el lenguaje Python en sí, es un problema histórico de diseño de intérpretes.
  • En el estado sin bloqueo, la eficiencia de ejecución de programas de subprocesos múltiples no es alta, o incluso no es tan eficiente como los de un solo subproceso.
  • El subproceso múltiple de Python solo es adecuado para la ejecución de tareas con retrasos de bloqueo .