Programación con Hilos en Python

Un Hilo es una unidad básica de utilización de la CPU; comprende un ID de hilo, un contador de programa, un conjunto de registros y una pila. Comparte con otros hilos 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 tiene un solo hilo de control. Si un proceso tiene, por lo contrario, múltiples hilos de control, puede realizar más de una tarea a la vez
Los hilos se inventaron para permitir la combinación del paralelismo con la ejecución secuencial y el bloqueo de las llamadas al sistema

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.

#!/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()

EL GIL
La ejecución de los threads en Python está controlada por el GIL (Global Interpreter Lock) de forma que sólo un thread puede ejecutarse a la vez, independientemente del número de procesadores con el que cuente la máquina. Esto posibilita que el escribir extensiones en C para Python sea mucho más sencillo, pero tiene la desventaja de limitar mucho el rendimiento, por lo que a pesar de todo, en Python, en ocasiones nos puede interesar más utilizar procesos que threads, que no sufren de esta limitación.


Ejemplo #1

1. #!/usr/bin/env python
2. # -*- coding: utf-8 -*-
4. from multiprocessing import Process, Queue
5. from urllib2 import urlopen, URLError
6. from Queue import Empty
8. # Carácteres alfanuméricos.
9. NAME_VALID_CHARS = [chr(i) for i in range(48, 58) + range(97, 123)]
11. def chars_filter(s):
12. """Remover carácteres inválidos."""
13. return "".join(
14. [c if c in NAME_VALID_CHARS else "" for c in s.lower()]
15. )
17. def download_page_content(url):
18. print "Descargando %s..." % url
19. try:
20. r = urlopen(url)
21. except URLError as e:
22. print "Error al acceder a %s." % url
23. print e
24. else:
25. filename = chars_filter(url.lower()) + ".html"
26. try:
27. f = open(filename, "w")
28. except IOError as e:
29. print "Error al abrir %s." % filename
30. print e
31. else:
32. f.write(r.read())
33. f.close()
34. r.close()
36. def worker(queue):
37. """
38. Toma un ítem de la cola y descarga su contenido,
39. hasta que la misma se encuentre vacía.
40. """
41. while True:
42. try:
43. url = queue.get_nowait()
44. except Empty:
45. break
46. else:
47. download_page_content(url)
49. def main():
50. urls = (
51. "http://python.org/",
52. "http://perl.org/",
53. "http://ruby-lang.org/",
54. "http://rust-lang.org/",
55. "http://php.net/",
56. "http://stackless.com/",
57. "http://pypy.org/",
58. "http://jython.org/",
59. "http://ironpython.net/"
60. )
62. queue = Queue(9)
63. for url in urls:
64. queue.put(url)
66. processes = []
67. for i in range(3):
68. processes.append(Process(target=worker, args=(queue,)))
69. processes[i].start()
70. print "Proceso %d lanzado." % (i + 1)
72. for process in processes:
73. process.join()
75. print u"La ejecución a concluído."
77. if __name__ == "__main__":
78. main()

Ejemplo #2

1. #!/usr/bin/env python
2. # -*- coding: utf-8 -*-
4. from multiprocessing import Process, Queue
5. from urllib.request import urlopen
6. from urllib.error import URLError
7. from time import time
8. from queue import Empty
10. # Carácteres alfanuméricos.
11. NAME_VALID_CHARS = [chr(i) for i in list(range(48, 58)) + list(range(97, 123))]
13. def chars_filter(s):
14. """Remover carácteres inválidos."""
15. return "".join(
16. [c if c in NAME_VALID_CHARS else "" for c in s.lower()]
17. )
19. def download_page_content(url):
20. print("Downloading %s..." % url)
21. try:
22. r = urlopen(url)
23. except URLError as e:
24. print("Error al acceder a %s." % url)
25. print(e)
26. else:
27. filename = chars_filter(url.lower()) + ".html"
28. try:
29. f = open(filename, "w")
30. except IOError as e:
31. print("Error al abrir %s." % filename)
32. print(e)
33. else:
34. f.write(r.read())
35. f.close()
36. r.close()
38. def worker(queue):
39. """
40. Toma un ítem de la cola y descarga su contenido,
41. hasta que la misma se encuentre vacía.
42. """
43. while True:
44. try:
45. url = queue.get_nowait()
46. except Empty:
47. break
48. else:
49. download_page_content(url)
51. def main():
52. urls = (
53. "http://python.org/",
54. "http://perl.org/",
55. "http://ruby-lang.org/",
56. "http://rust-lang.org/",
57. "http://php.net/",
58. "http://stackless.com/",
59. "http://pypy.org/",
60. "http://jython.org/",
61. "http://ironpython.net/"
62. )
64. queue = Queue(9)
65. for url in urls:
66. queue.put(url)
68. processes = []
69. for i in range(3):
70. processes.append(Process(target=worker, args=(queue,)))
71. processes[i].start()
72. print("Proceso %d lanzado." % (i + 1))
74. for process in processes:
75. process.join()
77. print("La ejecución a concluído.")
79. if __name__ == "__main__":
80. main()

Ejemplo #3

Ejemplo #4