Paralelismo basado en hilos en Python

Un programa de subprocesos múltiples consiste en subprogramas, cada uno de los cuales es manejado por separado por diferentes subprocesos. Los subprocesos múltiples permiten el paralelismo en la ejecución del programa. Todos los subprocesos activos se ejecutan simultáneamente, compartiendo los recursos de la CPU de manera efectiva y, por lo tanto, acelerando la ejecución del programa. Los subprocesos múltiples se utilizan generalmente cuando:

1. Hay subprogramas cuya salida debe combinarse con el programa principal.
2. El programa principal contiene secciones de código que son relativamente independientes entre sí.

Un programa de subprocesos múltiples maneja diferentes tareas al mismo tiempo, dentro del mismo proceso, donde diferentes subprocesos comparten el espacio de datos entre sí, así como el subproceso principal.

Comenzando un nuevo hilo

El módulo de subprocesos en python proporciona llamadas a funciones que se utilizan para crear nuevos subprocesos. La función __init__ se usa para inicializar los datos asociados con los nuevos subprocesos, mientras que la función de ejecución define el comportamiento del subproceso tan pronto como el subproceso comienza su ejecución.

Para crear un hilo nuevo:

1. Cree una subclase de la clase de hilo.
2. Anule la función __init__ de la clase de subproceso. Este método inicializará la fecha específica de un hilo.
3. Anule el método de ejecución para definir el comportamiento del subproceso.

# Python program to demonstrate
# initializing a new thread
import threading
  
class thread(threading.Thread):
    def __init__(self, thread_name, thread_ID):
        threading.Thread.__init__(self)
        self.thread_name = thread_name
        self.thread_ID = thread_ID
    def run(self):
        print(str(self.thread_name) +"  "+ str(self.thread_ID));
  
thread1 = thread("GFG", 1000)
thread2 = thread("GeeksforGeeks", 2000);
  
thread1.start()
thread2.start()
  
print("Exit")

Producción:

GFG 1000
GeeksforGeeks 2000
Exit

Módulo de roscado

El módulo de subprocesos en python proporciona un soporte potente y de alto nivel para subprocesos.

El módulo de subprocesamiento define las siguientes llamadas de función que se utilizan para obtener datos relacionados con subprocesos. Todas estas funciones se ejecutan atómicamente.

1. active_count(): devuelve la cantidad de objetos Thread actualmente vivos. El recuento devuelto es igual a la longitud de la lista devuelta por enumerate().
   Sintaxis:

   threading.active_count()

2. current_thread(): Devuelve el objeto Thread actual, correspondiente al hilo de control de la persona que llama. Si el hilo de control de la persona que llama no se creó a través del módulo de hilos, se devuelve un objeto de hilo ficticio con funcionalidad limitada.
   Sintaxis:

   threading.current_thread()

3. get_ident(): Devuelve el ‘identificador de hilo’ del hilo actual. Este es un entero distinto de cero. Su valor no tiene un significado directo; está pensado como una cookie mágica para ser utilizada, por ejemplo, para indexar un diccionario de datos específicos de subprocesos. Los identificadores de subprocesos se pueden reciclar cuando un subproceso sale y se crea otro subproceso.
   Sintaxis:

   threading.get_ident()

4. enumerar(): devuelve una lista de todos los objetos Thread actualmente vivos. La lista incluye subprocesos daemónicos, objetos de subprocesos ficticios creados por current_thread() y el subproceso principal. Excluye subprocesos terminados y subprocesos que aún no se han iniciado.
   Sintaxis:

   threading.enumerate()

5. main_thread(): Devuelve el objeto Thread principal. En condiciones normales, el subproceso principal es el subproceso desde el que se inició el intérprete de Python.
   Sintaxis:

   threading.main_thread()

6. settrace(func): establece una función de seguimiento para todos los subprocesos iniciados desde el módulo de subprocesos. La función se pasará a sys.settrace() para cada subproceso, antes de llamar a su método run().
   Sintaxis:

   threading.settrace(func)

7. setprofile(func): establece una función de perfil para todos los subprocesos iniciados desde el módulo de subprocesos. La función se pasará a sys.setprofile() para cada subproceso, antes de llamar a su método run().
   Sintaxis:

   threading.setprofile(func)

8. stack_size ([tamaño]): devuelve el tamaño de pila de subprocesos utilizado al crear nuevos subprocesos.
   Sintaxis:

   threading.stack_size([size])

Este módulo también incluye la constante:

• TIMEOUT_MAX: El valor máximo permitido para el parámetro de tiempo de espera de las funciones de bloqueo (Lock.acquire(), RLock.acquire(), Condition.wait(), etc.). Especificar un tiempo de espera mayor que este valor generará un OverflowError.
  Sintaxis:

  threading.TIMEOUT_MAX

# Python program to demonstrate
# threading module
import threading
  
def trace_function():
    print("Passing the trace function")
def profile():
    print("Setting the profile of thread: " + str(threading.current_thread().getName()))
  
class thread(threading.Thread):
    def __init__(self, thread_name, thread_ID):
        threading.Thread.__init__(self)
        self.thread_name = thread_name
        self.thread_ID = thread_ID
    def run(self):
        print(str(self.thread_ID));
        print("Number of active threads: "+ str(threading.active_count()))
        print("Name of current thread: " + str(threading.current_thread().getName()))
                                                 
  
  
thread1 = thread("GFG", 1000)
thread2 = thread("GeeksforGeeks", 2000);
print("Name of main thread: " + str(threading.main_thread().getName()))
print("Identity of main thread: "+ str(threading.get_ident()))
print("Stack size = " + str(threading.stack_size()))
print(threading.settrace(trace_function()))
threading.setprofile(profile())
  
  
thread1.start()
thread2.start()
print("Enumeration list: ")
print(threading.enumerate())
print("Exit")

Producción:

Name of main thread: MainThread
Identity of main thread: 139964150720320
Stack size = 0
Passing the trace function
None
Setting the profile of thread: MainThread
1000
Number of active threads: 2
Name of current thread: Thread-1
2000
Number of active threads: 2
Name of current thread: Thread-2
Enumeration list: 
[]
Exit

Referencia:

• Documentación de Python

Este artículo es una contribución de Mayank Kumar . Si le gusta GeeksforGeeks y le gustaría contribuir, también puede escribir un artículo usando contribuya.geeksforgeeks.org o envíe su artículo por correo a contribuya@geeksforgeeks.org. Vea su artículo que aparece en la página principal de GeeksforGeeks y ayude a otros Geeks.

Escriba comentarios si encuentra algo incorrecto o si desea compartir más información sobre el tema tratado anteriormente.