Multiproceso en Python con ejemplo:Aprenda GIL en Python

En un momento dado, un filósofo debe estar comiendo o pensando.

Además, un filósofo debe tomar los dos tenedores adyacentes a él (es decir, los tenedores izquierdo y derecho) antes de poder comer los espaguetis. El problema del interbloqueo ocurre cuando los cinco filósofos toman sus bifurcaciones derechas simultáneamente.

Como cada uno de los filósofos tiene un tenedor, todos esperarán a que los demás bajen el tenedor. Como resultado, ninguno de ellos podrá comer espaguetis.

De manera similar, en un sistema concurrente, se produce un interbloqueo cuando diferentes subprocesos o procesos (filósofos) intentan adquirir los recursos del sistema compartido (bifurcaciones) al mismo tiempo. Como resultado, ninguno de los procesos tiene la oportunidad de ejecutarse mientras esperan otro recurso en poder de otro proceso.

Condiciones de carrera

Una condición de carrera es un estado no deseado de un programa que ocurre cuando un sistema realiza dos o más operaciones simultáneamente. Por ejemplo, considere este bucle for simple:

i=0; # a global variable
for x in range(100):
    print(i)
    i+=1;

Si crea n número de subprocesos que ejecutan este código a la vez, no puede determinar el valor de i (que es compartido por los subprocesos) cuando el programa finaliza la ejecución. Esto se debe a que en un entorno real de subprocesos múltiples, los subprocesos pueden superponerse, y el valor de i que fue recuperado y modificado por un subproceso puede cambiar cuando otro subproceso accede a él.

Estas son las dos clases principales de problemas que pueden ocurrir en una aplicación de python multiproceso o distribuida. En la siguiente sección, aprenderá cómo superar este problema sincronizando subprocesos.

Sincronización de hilos

Para hacer frente a condiciones de carrera, interbloqueos y otros problemas relacionados con subprocesos, el módulo de subprocesos proporciona el Bloqueo objeto. La idea es que cuando un subproceso quiere acceder a un recurso específico, adquiere un bloqueo para ese recurso. Una vez que un subproceso bloquea un recurso en particular, ningún otro subproceso puede acceder a él hasta que se libere el bloqueo. Como resultado, los cambios en el recurso serán atómicos y se evitarán las condiciones de carrera.

Un bloqueo es una primitiva de sincronización de bajo nivel implementada por __thread módulo. En un momento dado, un candado puede estar en uno de dos estados:bloqueado o desbloqueado. Admite dos métodos:

1. adquirir() Cuando el estado de bloqueo está desbloqueado, llamar al método de adquisición () cambiará el estado a bloqueado y regresará. Sin embargo, si el estado está bloqueado, la llamada a adquirir() se bloquea hasta que algún otro subproceso llame al método release().
2. liberar() El método release() se usa para establecer el estado en desbloqueado, es decir, para liberar un bloqueo. Puede ser llamado por cualquier subproceso, no necesariamente por el que adquirió el bloqueo.

Este es un ejemplo del uso de bloqueos en sus aplicaciones. Encienda su IDLE y escriba lo siguiente:

import threading
lock = threading.Lock()

def first_function():
    for i in range(5):
        lock.acquire()
        print ('lock acquired')
        print ('Executing the first funcion')
        lock.release()

def second_function():
    for i in range(5):
        lock.acquire()
        print ('lock acquired')
        print ('Executing the second funcion')
        lock.release()

if __name__=="__main__":
    thread_one = threading.Thread(target=first_function)
    thread_two = threading.Thread(target=second_function)

    thread_one.start()
    thread_two.start()

    thread_one.join()
    thread_two.join()

Ahora, pulsa F5. Debería ver una salida como esta:

EXPLICACIÓN DEL CÓDIGO

1. Aquí, simplemente está creando un nuevo bloqueo llamando a threading.Lock() función de fábrica. Internamente, Lock() devuelve una instancia de la clase Lock concreta más eficaz que mantiene la plataforma.
2. En la primera declaración, adquiere el bloqueo llamando al método de adquisición(). Cuando se ha otorgado el bloqueo, imprime "bloqueo adquirido" a la consola Una vez que todo el código que desea que ejecute el subproceso haya terminado de ejecutarse, libere el bloqueo llamando al método release().

La teoría está bien, pero ¿cómo sabes que la cerradura realmente funcionó? Si observa la salida, verá que cada una de las declaraciones de impresión está imprimiendo exactamente una línea a la vez. Recuerde que, en un ejemplo anterior, los resultados de la impresión eran aleatorios porque varios subprocesos accedían al método print() al mismo tiempo. Aquí, la función de impresión se llama solo después de que se adquiere el bloqueo. Por lo tanto, las salidas se muestran una a la vez y línea por línea.

Además de los bloqueos, python también admite otros mecanismos para manejar la sincronización de subprocesos, como se indica a continuación:

1. Bloques
2. Semáforos
3. Condiciones
4. Eventos, y
5. Barreras

Bloqueo de intérprete global (y cómo solucionarlo)

Antes de entrar en los detalles de GIL de Python, definamos algunos términos que serán útiles para comprender la siguiente sección:

1. Código vinculado a la CPU:se refiere a cualquier pieza de código que será ejecutada directamente por la CPU.
2. Código vinculado a E/S:puede ser cualquier código que acceda al sistema de archivos a través del sistema operativo
3. CPython:es la implementación de referencia de Python y se puede describir como el intérprete escrito en C y Python (lenguaje de programación).

¿Qué es GIL en Python?

Bloqueo de intérprete global (GIL) en python es un bloqueo de proceso o un mutex que se usa al tratar con los procesos. Se asegura de que un subproceso pueda acceder a un recurso en particular a la vez y también evita el uso de objetos y códigos de bytes a la vez. Esto beneficia a los programas de subproceso único en un aumento del rendimiento. GIL en python es muy simple y fácil de implementar.

Se puede usar un bloqueo para asegurarse de que solo un subproceso tenga acceso a un recurso en particular en un momento dado.

Una de las características de Python es que utiliza un bloqueo global en cada proceso de interpretación, lo que significa que cada proceso trata al intérprete de Python como un recurso.

Por ejemplo, suponga que ha escrito un programa de Python que utiliza dos subprocesos para realizar operaciones de CPU y de "E/S". Cuando ejecuta este programa, esto es lo que sucede:

1. El intérprete de python crea un nuevo proceso y genera los subprocesos
2. Cuando el subproceso 1 comience a ejecutarse, primero adquirirá el GIL y lo bloqueará.
3. Si el subproceso 2 quiere ejecutarse ahora, tendrá que esperar a que se libere el GIL incluso si hay otro procesador libre.
4. Ahora, supongamos que el subproceso 1 está esperando una operación de E/S. En ese momento, liberará el GIL y thread-2 lo adquirirá.
5. Después de completar las operaciones de E/S, si el subproceso 1 quiere ejecutarse ahora, nuevamente tendrá que esperar a que el subproceso 2 libere el GIL.

Debido a esto, solo un subproceso puede acceder al intérprete en cualquier momento, lo que significa que solo habrá un subproceso ejecutando código python en un momento determinado.

Esto está bien en un procesador de un solo núcleo porque estaría usando la división de tiempo (vea la primera sección de este tutorial) para manejar los subprocesos. Sin embargo, en el caso de los procesadores multinúcleo, una función vinculada a la CPU que se ejecute en varios subprocesos tendrá un impacto considerable en la eficiencia del programa, ya que en realidad no utilizará todos los núcleos disponibles al mismo tiempo.

¿Por qué se necesitaba GIL?

El recolector de elementos no utilizados de CPython utiliza una técnica de gestión de memoria eficiente conocida como recuento de referencias. Así es como funciona:cada objeto en python tiene un recuento de referencias, que aumenta cuando se asigna a un nuevo nombre de variable o se agrega a un contenedor (como tuplas, listas, etc.). Del mismo modo, el recuento de referencias se reduce cuando la referencia queda fuera del alcance o cuando se llama a la instrucción del. Cuando el recuento de referencias de un objeto llega a 0, se recolecta basura y se libera la memoria asignada.

Pero el problema es que la variable de conteo de referencia es propensa a condiciones de carrera como cualquier otra variable global. Para resolver este problema, los desarrolladores de python decidieron utilizar el bloqueo de intérprete global. La otra opción era agregar un bloqueo a cada objeto, lo que habría resultado en interbloqueos y un aumento de la sobrecarga de las llamadas de adquisición () y liberación ().

Por lo tanto, GIL es una restricción significativa para los programas de Python multihilo que ejecutan operaciones pesadas vinculadas a la CPU (haciéndolos efectivamente de un solo hilo). Si desea utilizar varios núcleos de CPU en su aplicación, utilice el multiprocesamiento módulo en su lugar.

Resumen

• Python admite 2 módulos para subprocesos múltiples:
  1. __hilo módulo:proporciona una implementación de bajo nivel para subprocesos y está obsoleto.
  2. módulo de hilos :proporciona una implementación de alto nivel para subprocesos múltiples y es el estándar actual.
• Para crear un hilo usando el módulo de hilos, debe hacer lo siguiente:
  1. Cree una clase que amplíe el hilo clase.
  2. Anular su constructor (__init__).
  3. Anular su run() método.
  4. Cree un objeto de esta clase.
• Se puede ejecutar un subproceso llamando a start() método.
• El join() El método se puede usar para bloquear otros subprocesos hasta que este subproceso (aquel en el que se llamó a join) finalice la ejecución.
• Se produce una condición de carrera cuando varios subprocesos acceden o modifican un recurso compartido al mismo tiempo.
• Se puede evitar sincronizando hilos.
• Python admite 6 formas de sincronizar subprocesos:
  1. Cerraduras
  2. Bloques
  3. Semáforos
  4. Condiciones
  5. Eventos, y
  6. Barreras
• Los bloqueos permiten que solo un subproceso en particular que haya adquirido el bloqueo ingrese a la sección crítica.
• Un candado tiene 2 métodos principales:
  1. adquirir() :Establece el estado de bloqueo en bloqueado. Si se invoca en un objeto bloqueado, se bloquea hasta que el recurso esté libre.
  2. liberar() :Establece el estado de bloqueo en desbloqueado y regresa Si se invoca en un objeto desbloqueado, devuelve falso.
• El bloqueo de intérprete global es un mecanismo a través del cual solo se puede ejecutar 1 proceso de intérprete de CPython a la vez.
• Se usó para facilitar la funcionalidad de conteo de referencias del recolector de basura de CPythons.
• Para crear aplicaciones de Python con operaciones intensivas vinculadas a la CPU, debe usar el módulo de multiprocesamiento.