Programas enhebrados en Python

En informática, un hilo se define como la unidad de ejecución más pequeña con un conjunto independiente de instrucciones. En términos simples, un subproceso es un flujo separado, lo que significa que nuestro programa tendrá dos cosas sucediendo al mismo tiempo, pero para la mayoría de las implementaciones de Python 3, los diferentes subprocesos en realidad no se ejecutan al mismo tiempo.

La ventaja de la programación de subprocesos es que permite al usuario ejecutar simultáneamente diferentes partes del programa y simplificar el diseño de su programa.

En la programación de subprocesos, diferentes procesadores se ejecutan en una sola placa y cada uno de ellos realiza una tarea independiente al mismo tiempo. Sin embargo, si queremos hacer multiprocesamiento, necesitamos ejecutar nuestro código en un lenguaje de programación diferente o necesitamos usar el módulo de multiprocesamiento.

En la implementación CPython de Python, las interacciones se realizan con Global Interpreter Lock (GIL) que siempre restringe la ejecución de un subproceso de Python a la vez. En cuanto a la creación de subprocesos, las tareas que pasan gran parte de su tiempo esperando eventos externos son buenas candidatas para la creación de subprocesos. Todo esto es cierto cuando el código está escrito en Python. Sin embargo, para la programación de subprocesos en C en lugar de Python, tienen la capacidad de liberar GIL y ejecutarse simultáneamente.

Veamos cómo iniciar un hilo en Python.

Comenzando un hilo:

Ahora, de la introducción anterior, tenemos una idea de lo que es un hilo, aprendamos cómo hacer uno. La biblioteca estándar de Python contiene un módulo llamado subprocesamiento que incluye todos los elementos básicos necesarios para comprender mejor el proceso de subprocesamiento. De acuerdo con este módulo, podemos encapsular hilos fácilmente y proporcionar una interfaz limpia para trabajar con ellos. Si queremos iniciar un subproceso en particular, primero debemos crear una instancia de Subproceso y luego .start():

Si miramos alrededor de las declaraciones de registro, podemos ver claramente que la sección principal está creando e iniciando el hilo:

t = enhebrar.Subproceso(objetivo = función_subproceso, argumentos = (1,)) t.start()

Cuando se crea un hilo, se ejecuta una función y una lista de argumentos para esa función. En el ejemplo anterior, thread_function() se ejecuta y se pasa 1 como argumento. Sin embargo, la función solo registra mensajes con am.sleep() entre ellos.

Trabajando con Múltiples Subprocesos: El código de muestra hasta ahora solo funciona con dos subprocesos: el subproceso principal y uno que comenzamos con el subprocesamiento. Un objeto de hilo. A menudo, querremos iniciar varios hilos y pedirles que hagan un trabajo interesante. El proceso de ejecutar varios subprocesos en paralelo se denomina subprocesos múltiples. Mejora el rendimiento del programa y los subprocesos múltiples de Python son bastante fáciles de aprender.

Comencemos a comprender los subprocesos múltiples usando el ejemplo que usamos anteriormente:

Este código funcionará de la misma manera que lo hizo en el proceso de iniciar un hilo. Primero, necesitamos crear un objeto Thread y luego llamar al objeto .start(). El programa luego mantiene una lista de objetos Thread. Luego los espera usando .join(). Los hilos se colocan en un orden diferente en este ejemplo. Esto se debe a que múltiples subprocesos generan diferentes comandos. El mensaje Subproceso x: finalización indica cuándo se completaron todos los subprocesos. El orden de los subprocesos lo determina el sistema operativo, por lo que es fundamental que conozca el diseño del algoritmo utilizado por el proceso de subprocesamiento.

Agente de grupo de subprocesos: Una forma más fácil de iniciar un grupo de subprocesos es usar ThreadpoolExecutor. Se encuentra en la biblioteca estándar de Python en el futuro concurrente, se puede crear un administrador de contexto utilizando la declaración de ayuda. Ayudará a administrar y destruir la piscina.

Un ejemplo para demostrar un implementador de Threadpool:

El código anterior crea un ThreadpoolExecutor e indica cuántos subprocesos de trabajo quiere en el grupo y luego usa .map() para iterar a través de una lista de objetos. Cuando finaliza el bloque with, se utiliza .join() en cada uno de los subprocesos del grupo. Se recomienda usar ThreadpoolExecutor siempre que sea posible para que nunca olvide .join() con los subprocesos.

Condiciones de Carrera y Sincronización en Programación Hilo:

Cuando varios subprocesos intentan acceder a un dato o recurso compartido, se producen condiciones de carrera. Las condiciones de carrera producen resultados que son confusos para que un usuario los entienda y ocurren con poca frecuencia y son difíciles de depurar. Para resolver esta condición de carrera, necesitamos encontrar una manera de permitir que un subproceso a la vez entre en la sección de lectura, modificación y escritura de nuestro código. La forma más común de hacer esto es con Lock in Python. En otros idiomas, esta misma idea se llama mutex. Viene de MUTual Exclusion, que es exactamente lo que hace Lock. Glas es algo que actúa como un pase de pasillo que solo permitirá que un subproceso a la vez ingrese la parte del código de lectura, modificación y escritura. Si algún otro subproceso quiere unirse al mismo tiempo, debe esperar hasta que el propietario actual de la cerradura lo abandone.

Las funciones básicas son .get() y .release(). Un subproceso llamará a my_lock.acquire() para adquirir el bloqueo. Sin embargo, este subproceso tendrá que esperar si otro subproceso retiene el bloqueo hasta que lo libere. El bloqueo en Python también funciona como un administrador de contexto y se puede usar dentro de una declaración with y se liberará automáticamente cuando finalice un bloque. Tomemos el ejemplo de la clase FalseDatabase y agreguemos un Lock:

Un bloqueo es parte del objeto threading.Lock() y se inicializa en el estado desbloqueado y luego se libera con la ayuda de una declaración with.

Objetos en Threading: Hay algunos otros módulos de subprocesamiento en Python que se pueden usar en diferentes situaciones. Incluye lo siguiente:

Semáforo: El primer objeto de enhebrado de Python que se debe observar es threading.Semaphore. Un semáforo es un módulo contador que tiene pocas propiedades únicas. La primera propiedad es que su cuenta es atómica, lo que significa que el sistema operativo no intercambiará el subproceso mientras aumenta o disminuye el contador. El contador interno se incrementa cuando llama a .release() y disminuye cuando llama a .acquire().

La otra propiedad es que si un subproceso llama a .acquire() mientras el contador es cero, entonces el subproceso se bloqueará hasta que otro subproceso llame a .release(). El trabajo principal de los semáforos es proteger un recurso que tiene una capacidad limitada. Se utiliza en los casos en los que tiene un grupo de conexiones y desea limitar el tamaño del grupo a un número determinado.

Temporizador: El módulo de temporizador se usa para programar una función para que se llame después de que haya pasado una cierta cantidad de tiempo. Necesitamos pasar unos segundos para esperar y llamar a una función para crear un temporizador:
t = threading.Timer(20.0,my_timer_function) iniciamos el temporizador llamando a .start(). La función se llamará en un nuevo subproceso en algún momento después del tiempo especificado, pero tenga en cuenta que no hay garantía de que se llame exactamente en el momento que queremos.

Si queremos detener Timire que ya ha comenzado, podemos cancelarlo llamando a .cancel(). Una llamada a .cancel() después de que se haya disparado el temporizador no hace nada y no arroja ninguna excepción.
Se puede usar un temporizador para solicitar a un usuario que realice una acción después de un cierto período de tiempo. Si el usuario realiza la acción antes de que expire el temporizador, se puede llamar a .cancel().

Conclusión: En este artículo, hemos cubierto la mayoría de los temas relacionados con la programación de subprocesos en Python. Hemos discutido, ¿Qué es el subproceso donde discutimos en profundidad sobre el subproceso, cómo crearlo y cómo iniciar un subproceso en nuestro programa, luego de haber discutido sobre los subprocesos múltiples y varias complicaciones de subprocesos como Condiciones de carrera después de eso discutimos cómo evitar estas dificultades en nuestro programa con la ayuda de la sincronización y finalmente entendemos las cosas en el enhebrado. Por lo tanto, los subprocesos de Python nos permiten ejecutar diferentes partes de nuestro programa al mismo tiempo y, con esto, podemos simplificar nuestro diseño. Si tiene algo de experiencia con Python y quiere acelerar su programa usando subprocesos, entonces este artículo es adecuado para ellos.

👉 Aqui tienes mas python tutoriales para aprender.

5 comentarios en «Programas enhebrados en Python»

  1. ¡Creo que Python es la clave para revolucionar la programación! ¿Quién está conmigo? 🐍💻

    • ¡En realidad, creo que cada lenguaje de programación tiene sus ventajas y desventajas! Es importante elegir la herramienta adecuada para cada proyecto en particular. ¡La diversidad en programación es clave para la innovación! 🌟👩‍💻🚀

  2. ¡No estoy de acuerdo! Python es clave en el desarrollo de programas enhebrados.

  3. ¿Realmente Python es la mejor opción para programas enhebrados? ¡Debatamos! 🤔🐍

    • ¡Claro que sí! Python ofrece muchas ventajas para programas enhebrados, como su sintaxis clara y legible, así como su amplia gama de bibliotecas. Sin duda, es una excelente opción para este tipo de aplicaciones. ¡No hay debate! 🐍💻

Los comentarios están cerrados.