Programación de Threads con Python

¿QUE ES UN THREAD?
Aquí tienen una definición:

“Una hebra es una unidad básica de utilización de la CPU; comprende un ID de hebra, un contador de programa, un conjunto de registros y una pila. Comparte con otras hebras que pertenecen al mismo proceso la sección de código, la sección de datos y otros recursos del sistema operativo, como los archivos abiertos y las señales. Un proceso tradicional (o un proceso pesado) tiene una sola hebra de control. Si un proceso tiene, por lo contrario, múltiples hebras de control, puede realizar más de una tarea a la vez.” [Fundamentos de sistemas operativos (Septina edicion en Español), Autores: Silberschatz, Galván, Gagne ISBN: 84-481-4641-7 Editorial McGraw-Hill]

Esta es otra definición:

“En la mayoría de los sistemas operativos tradicionales, cada proceso tiene un espacio de direcciones y un único hilo de control. De hecho, esa es casi la definición de un proceso. Sin embargo, con frecuencia existen situaciones en donde se desea tener varios hilos de control que compartan un único espacio de direcciones, pero que ejecutan de manera quasi-paralela, como si fuera de hecho procesos independientes (excepto por el espacio de direcciones compartido)” [Sistemas Operativos Modernos Autor: Andrew S. Tanenbaum ISBN: 968-880-323-5 Editorial: Prentice Hall]

¿PARA QUÉ SIRVE?

“Los hilos se inventaron para permitir la combinación del paralelismo con la ejecución secuencial y el bloqueo de las llamadas al sistema” [Sistemas Operativos Modernos Autor: Andrew S. Tanenbaum ISBN: 968-880-323-5 Editorial: Prentice Hall]

¿CÓMO PROGRAMAR UNO EN PYTHON?

Bueno basta de citas y de libros, si están leyendo esto es por que quieren hacer hilos en python. Para esto tendremos que importar el paquete threading. Y luego crear una clase que herede de threading.Thread. Si queremos que esta clase tenga un constructor propio tendrá que invocar también al constructor de Thread. Esto lo hace invocando a threading.Thread.__init__(self).

Dentro de la clase rescribiremos el método run. Y dentro de el pondremos el código que queramos que ejecute nuestro hilo.

Luego instanciaremos un objeto con nuestra clase. Y para que empiece a ejecutar solo tendremos que invocar al método start de nuestro objeto.

Un ejemplo simple podría ser el de hilo.py

#!/usr/bin/python
# Nombre de Fichero : hilo.py
import threading
from time import sleep

class Hilo(threading.Thread):
  def __init__(self, id):
      threading.Thread.__init__(self)
      self.id = id

  def run(self):
      sleep(3-self.id)
      print "Yo soy %s la variable d tiene el valor %s"%(self.id,d)

d=1;
hilos = [Hilo(1),
   Hilo(2),
   Hilo(3)]

for h in hilos:
  h.start()

fijemosnos que todos los hilos comparten la variable d.

A continuación un ejemplo de cómo se ejecutan dos programas secuenciales con hilos. Acá esta el código que hice espero que a alguien le sirva.

#!/usr/bin/python
# Nombre de Fichero : lote.py
import threading
from os import system
from time import sleep

class Trabajo(threading.Thread):
  """
  Esta es la clase Trabajo. Los Trabajos  se pueden ejecutar de 4 maneras
  Que esperen a estar solos para ejecutarse.
  Que esperen a estar solos para ejecutarse y no dejar ejecutar ningun otro hasta terminar.
  Que no dejen ejecutar a ninguno otro hasta terminar.
  Que se ejecuten sin restricciones mientras los otros lo dejen
  """
  def __init__(self, id, cmd, entroSolo = False ,salgoSolo = False):
      threading.Thread.__init__(self)
      self.cmd = cmd
      self.id = id
      self.entroSolo = entroSolo
      self.salgoSolo = salgoSolo

  def run(self):
      system(self.cmd)

print "lotePy  0.0.1"

tabajos = [Trabajo(1,"calc",True,True),
         Trabajo(2,"Notepad",True),
         Trabajo(3,"dir c:\\",True)]

for t in tabajos:
  while (t.entroSolo)  and (threading.activeCount() != 1):pass
  t.start()
  if (t.salgoSolo):
      t.join()