Python / Los datos locales de un thread

Bienvenidos sean a este post, hoy veremos como implementar datos locales en un thread.

El modulo threading nos permite implementar datos locales para un thread, el dato local es un objeto que contiene datos especificos del thread, para ello vamos a crear un ejemplo y lo primero que haremos sera importar los elementos necesarios:

>>> import threading
>>> from random import randint

El primero sera para manejar los thread y el segundo para generar numeros al azar, con nuestros elementos importados pasemos a crear el siguiente objeto:

>>> local = threading.local()

Este es un objeto especial que nos pemite almacenar datos especificos para el thread, pasemos a definir una funcion:

>>> def correr(local, barrera):
...     local.mi_valor = randint(0, 10**2)
...     t = threading.current_thread()
...     print(f'Thread {t.name} tiene el valor {local.mi_valor}')
...     barrera.wait()
...     print(f'Thread {t.name} aun tiene el valor {local.mi_valor}')
... 
>>>

Esta funcion recibe dos valores, el primero sera para los valores locales del thread y otro que sera una barrera, aqui guardaremos un valor al azar en local.mi_valor, despues almacenaremos el thread actual en un objeto, imprimiremos un texto con el nombre del thread actual y el valor almacenado en local.mi_valor, aqui usamos a wait de barrera para esperar, el objeto Barrier que contiene barrera es una sincronizacion primitiva para usar por un numero determinado de threads que necesitan esperar uno al otro, el wait es utilizado para pasar la barrera pero esta no podra pasarla hasta que todos los threads hayan utilizado el wait, por ultimo volvemos a mostrar el valor interno del thread, con esto tenemos todo concluido en la funcion, para nuestro siguiente paso crearemos una nueva variable:

>>> contar = 3

Con nuestra variable establecida vamos a crear un nuevo objeto de tipo Barrier:

>>> barrera = threading.Barrier(contar)

En este caso crearemos el objeto llamado barrera y recuerdan cuando hablamos del objeto Barrier dijimos que informabamos la cantidad de threads que vamos a manejar, nuestro siguiente paso sera crear el objeto para los threads:

>>> threads = [threading.Thread(target=correr, name=f'T{nombre}',
...     args=(local, barrera)) for nombre in range(contar)]
>>>

Aqui crearemos varios threads, para ello usaremos a Thread como antes pero con un par de diferencias, en target pasamos la funcion que definimos antes, luego en name pasamos el nombre de cada thread que en realidad es T seguido de un numero, luego en args pasamos a local y la barrera, para cada nombre usaremos un bucle for donde le asignaremos los valores obtenidos del range de contar, con esto estarian creados los threads, veamos como recuperarlos:

>>> for t in threads:
...     t.start()
...

Aqui guardaremos a cada thread creado en threads en t y lo siguiente sera iniciar cada thread con start, veamos su salida:

Thread T0 tiene el valor 61
Thread T1 tiene el valor 90
Thread T2 tiene el valor 24
>>> Thread T0 aun tien el valor 61
Thread T1 aun tiene el valor 90
Thread T2 aun tiene el valor 24

Observen como mostramos los valores de cada thread y despues de superada la barrera (Barrier) podemos ver como nos muestra que los mismos valores aun estan dentro del thread, es decir que siempre que deseemos manejar algun dato en particular para nuestro threads debemos usar a local de threading.

En resumen, hoy hemos visto como trabajar con datos locales en threads, hemos visto cual es la funcion que nos los permite, hemos visto muy superficialmente al Barrier, como trabaja y como podemos tener informacion en el thread propiamente, espero les haya sido util sigueme en tumblr, Twitter o Facebook para recibir una notificacion cada vez que subo un nuevo post en este blog, nos vemos en el proximo post.