Testear módulos de python puede hacerse fácilmente con el módulo unittest. Con este módulo (y el tuyo), puedes explorar cuánto de bueno es tu código. El módulo debe ser usado con algunos truquitos para obtener todo su potencial, por lo que espero que mi ejemplo sea instructivo.

Para empezar, quiero mostrarte algo de teoría de test. Testear un módulo o un programa se divide en testsuites, una testsuite está compuesta de testcases. Cada testsuite prueba una feature (o característica) del módulo, y cada testcase debe probar una o más funciones o métodos de esa feature. Un ejemplo:

• testsuite1 <-> Feature 1
  • testcase1
  • testcase2
• testsuite2 <-> Feature 2
  • testcase1
  • testcase2

Todo eso esta muy bien, pero ¿cómo aplicarlo a un ejemplo? Lo primero de todo, cuando desarrollo un nuevo módulo, creo un nuevo test para ese módulo en un directorio llamado test (no muy original . En ese directorio, guardo los tests de una serie de módulos relacionados, y a continuación muestro un ejemplo (no real) de uno de estos tests:

from sys import path

path.append ('..')from Module import Module, ModuleError

import unittest, logging

class ModuleMethods (unittest.TestCase):

    logging.basicConfig (level = logging.DEBUG,

        format = '%(asctime)s %(levelname)-8s %(message)s')

def setUp (self): # Esto se ejecuta cada vez que se lanza un test
        self.instance = Module (parameters)

def test_method1 (self): # Primer método, comprueba el valor devuelto
        r = self.instance.method1 (params)

        logging.debug ('r = %s' % str (r))

 self.failUnless (r[0] == 0)

def test_method2 (self): # Segundo método, comprueba si lanza una excepción
  	self.failUnlessRaises (ModuleError, self.instance.method2, params)

def tearDown (self): # Ésto se ejecuta después de que cada test haya finalizado
  	pass # Some test tearDown

def run (): # Función de lanzamiento del testcase
    suite = unittest.TestLoader ().loadTestsFromTestCase (ModuleMethods)

    unittest.TextTestRunner (verbosity = 2).run (suite)
 #Punto de entrada de los test
if __name__ == '__main__':

    run ()

Este ejemplo muestra un ejemplo sencillo de cómo crear un testcase, suficiente para un módulo o una clase con algunos pocos métodos o funciones. El ejemplo crea una nueva clase de testing (heredando de unittest.TestCase) y define algunos métodos test_*, estos métodos serán automáticamente invocados cuando el testRunner sea lanzadao en la función run.

En cada método, se prueba un método objetivo, estos métodos son muy simples, pero puedes crear otros mucho más complejos. Una definición de uno de estos métodos es la siguiente:

1. Alguna (o ninguna) configuración del objetivo.
2. Ejecución del método objetivo.
3. Manejo de retornos o exceptiones para determinar si el test es PASS (OK) o FAIL (Fallido).

Puedes observar funciones como failUnless o failUnlessRaises que hacen comprobaciones condicionales. Si una o más fallan, el test se considera FAIL. Hay dos tipos de FAIL:

• Error: Un error es un test que no ha fallado alguna verificación, sino que lanza alguna excepción inesperada, bien sea por fallo en el módulo o por fallo en la escritura del testcase.
• Failure: Un test que no cumple con las condiciones de todos los chequeos establecidos.

Por ahora, toda esta información es suficiente. Para más información acerca del framework de pruebas, visita este enlace.

Nos vemos! Se aprecia cualquier comentario.

Testing in python can be made by the powerful unittest module. With this module (and yours), you can explore if your code is good or not good. The module must to be used with some kinds of tips & tricks, but I hope this example result helpful.

To start I want to show you some testing theory. The testing of a module is divided in testsuites, one testsuite is a set of testcases. Each testsuite tests one feature of your module, and each testcase must test one or more functions or methods of that feature. And example:

• testsuite1 <-> Feature 1
  • testcase1
  • testcase2
• testsuite2 <-> Feature 2
  • testcase1
  • testcase2

All of this is ok, but how to apply this to an example? First of all, when I develop a new module, I create a new test for that module in a test directory inside the module’s directory. In that directory, I store all the tests for a given set of related modules, and this is one example of one of that tests:

from sys import path

path.append ('..')from Module import Module, ModuleError

import unittest, logging

class ModuleMethods (unittest.TestCase):

    logging.basicConfig (level = logging.DEBUG,

        format = '%(asctime)s %(levelname)-8s %(message)s')

def setUp (self): # This is executed each time a test is launched

        self.instance = Module (parameters)

def test_method1 (self): # First method, check value returned

        r = self.instance.method1 (params)

        logging.debug ('r = %s' % str (r))

 self.failUnless (r[0] == 0)

def test_method2 (self): # Second method, check exception

  	self.failUnlessRaises (ModuleError, self.instance.method2, params)

def tearDown (self): # This is executed after each test finished

  	pass # Some test tearDown

def run (): # Running function of the test

    suite = unittest.TestLoader ().loadTestsFromTestCase (ModuleMethods)

    unittest.TextTestRunner (verbosity = 2).run (suite)

#Entry point of the test

if __name__ == '__main__':

    run ()

This example shows you a simple example about creating a testcase, this is enough for a module or class with only a few functions or methods. This example creates a new class of testing (with unittest.TestCase as base class) and define some test_* methods, these methods are automatically invoked when the testRunner will be called in the run function.

In each method, a target method is tested, these methods are pretty simple, but you can make it a lot more complex ones. A definition for one of these methods is the following:

1. Some configuration of the target.
2. Target execution.
3. Return value (or exception) handling to determine a FAIL or PASS test.

You can see functions like failUnless or failUnlessRaises that makes some conditional checks, if one or more fails, that test is considered FAIL. There are two types of FAIL:

• Error: An error is a test that raises some unexpected exception, this can be a wrong test or a problem in the target module code.
• Failure: A typical error of module code that doesn’t pass all checks made in the test.

For now, I think this information is enough. For further information about this testing framework, check this link.

See you! Comments welcomed.

from threading import Thread, Lock

array = []
myLock = Lock ()
elements = 10

class Producer (Thread):
	def run (self):
		for i in range (elements):
			myLock.acquire ()
			array.append (i)
			myLock.release ()
			print '-> Produced %d' % i

class Consumer (Thread):
	def run (self):
		consumed = 0
		while consumed < elements:
			myLock.acquire ()
			if len (array) > 0:
				e = array[0]
				del array[0]
			myLock.release ()
			print '<- Consumed %d' % e
			consumed += 1

if __name__ == '__main__':
	p1 = Producer ()
	p2 = Producer ()
	c1 = Consumer ()
	c2 = Consumer ()
	p1.start ()
	c1.start ()
	p2.start ()
	c2.start ()
	p1.join ()
	p2.join ()
	c1.join ()
	c2.join ()

Lo primero que se observa es la declaración de variables, incluyendo un Lock (o candado) para el acceder correctamente a la variable compartida array. Después se definen las dos clases principales, una para el productor y la otra para el consumidor. En el final, en el programa principal, se crean dos productores y dos consumidores y se ejecutan hasta el final. Para que los threads acaben correctamente, debes hacer join de todas las instancias. La salida que muestra el script es la siguiente:

-> Produced 0
-> Produced 1
-> Produced 2
-> Produced 3
-> Produced 4
-> Produced 5
-> Produced 6
-> Produced 7
-> Produced 8
<- Consumed 0
<- Consumed 1
<- Consumed 2
-> Produced 9
<- Consumed 3
<- Consumed 4
<- Consumed 5
<- Consumed 6
<- Consumed 7
-> Produced 0
-> Produced 1
-> Produced 2
<- Consumed 8
<- Consumed 9
-> Produced 3
-> Produced 4
-> Produced 5
-> Produced 6
-> Produced 7
<- Consumed 0
<- Consumed 1
<- Consumed 2
<- Consumed 3
<- Consumed 4
-> Produced 8
-> Produced 9
<- Consumed 5
<- Consumed 6
<- Consumed 7
<- Consumed 8
<- Consumed 9

Esto es todo por ahora, mantente a la escucha . Nos vemos!

from threading import Thread, Lock

array = []
myLock = Lock ()
elements = 10

class Producer (Thread):
	def run (self):
		for i in range (elements):
			myLock.acquire ()
			array.append (i)
			myLock.release ()
			print '-> Produced %d' % i

class Consumer (Thread):
	def run (self):
		consumed = 0
		while consumed < elements:
			myLock.acquire ()
			if len (array) > 0:
				e = array[0]
				del array[0]
			myLock.release ()
			print '<- Consumed %d' % e
			consumed += 1

if __name__ == '__main__':
	p1 = Producer ()
	p2 = Producer ()
	c1 = Consumer ()
	c2 = Consumer ()
	p1.start ()
	c1.start ()
	p2.start ()
	c2.start ()
	p1.join ()
	p2.join ()
	c1.join ()
	c2.join ()

First, you see some variable declaration, including a declaration for a Lock in order to make correct access to the shared variable array. Then two classes are defined, the main classes, one for the producer and another for the consumer. At the end, in the main program, we create two producers and two consumers and they’re running until the end of their lives. For thread right end, you must join all instances. The output showed by this script is:

-> Produced 0
-> Produced 1
-> Produced 2
-> Produced 3
-> Produced 4
-> Produced 5
-> Produced 6
-> Produced 7
-> Produced 8
<- Consumed 0
<- Consumed 1
<- Consumed 2
-> Produced 9
<- Consumed 3
<- Consumed 4
<- Consumed 5
<- Consumed 6
<- Consumed 7
-> Produced 0
-> Produced 1
-> Produced 2
<- Consumed 8
<- Consumed 9
-> Produced 3
-> Produced 4
-> Produced 5
-> Produced 6
-> Produced 7
<- Consumed 0
<- Consumed 1
<- Consumed 2
<- Consumed 3
<- Consumed 4
-> Produced 8
-> Produced 9
<- Consumed 5
<- Consumed 6
<- Consumed 7
<- Consumed 8
<- Consumed 9

This is all for now, stay tuned for more snippets . See you!

from threading import Thread import time
import random

criticalVar = 0
threads = 10

class MyThread (Thread):

	def __init__ (self, id):
		Thread.__init__ (self)
		self.TID = id # Thread id

	def run (self):
		global criticalVar
		print 'Thread [%d] starts' % self.TID
		localVar = criticalVar + 1
		time.sleep (random.random ()) # Some long call between 0 and 1
		criticalVar = localVar
		print 'Thread [%d] ends: criticalVar = %d' % (self.TID, criticalVar)

if __name__ == '__main__':
	s = time.time ()
	threadBag = []
	for id in range (threads):
		t = MyThread (id)
		t.start ()
		threadBag.append (t)
	for thread in threadBag:
		thread.join ()
	print 'Total time = %f' % (time.time () - s)

Este código muestra un ejemplo típico de threads. Si lanzas este ejemplo, mostrará:

Thread [0] starts
Thread [1] starts
Thread [2] starts
Thread [3] starts
Thread [4] starts
Thread [5] starts
Thread [6] starts
Thread [7] starts
Thread [8] starts
Thread [9] starts
Thread [0] ends: criticalVar = 1
Thread [2] ends: criticalVar = 1
Thread [3] ends: criticalVar = 1
Thread [9] ends: criticalVar = 1
Thread [4] ends: criticalVar = 1
Thread [5] ends: criticalVar = 1
Thread [7] ends: criticalVar = 1
Thread [8] ends: criticalVar = 1
Thread [1] ends: criticalVar = 1
Thread [6] ends: criticalVar = 1
Total time = 0.872000

La salida muestra una preciosa condición de carrera en criticalVar ya que todos los threads leen la variable, hacen algo que consume tiempo y la escriben después de que todos la hayan leido. Este comportamiento lleva a un fallo porque la función run() no es segura para threads (thread-safety).

Pero, con un pequeño decorador y alguna magía de locks…

from threading import Thread, Lock
import time
import random

criticalVar = 0
threads = 10
myLock = Lock ()

def sync (lock):
	def function (f):
		def wrapper (*args, **kargs):
			lock.acquire ()
			try:
				return f(*args, **kargs)
			finally: # exec in all cases
				lock.release ()
		return wrapper
	return function

class MyThread (Thread):

	def __init__ (self, id):
		Thread.__init__ (self)
		self.TID = id # Thread id

	@sync (myLock)
	def run (self):
		global criticalVar
		print 'Thread [%d] starts' % self.TID
		localVar = criticalVar + 1
		time.sleep (random.random ()) # Some long call between 0 and 1
		criticalVar = localVar
		print 'Thread [%d] ends: criticalVar = %d' % (self.TID, criticalVar)

if __name__ == '__main__':
	s = time.time ()
	threadBag = []
	for id in range (threads):
		t = MyThread (id)
		t.start ()
		threadBag.append (t)
	for thread in threadBag:
		thread.join ()
	print 'Total time = %f' % (time.time () - s)

Ésta es la versión segura. Con el decorador al principio de la función run(), cada thread tiene que adquirir el lock y liberarlo al terminar. Por lo que el decorador hace la función run() segura ant threads y la salida queda:

Thread [0] starts
Thread [0] ends: criticalVar = 1
Thread [1] starts
Thread [1] ends: criticalVar = 2
Thread [2] starts
Thread [2] ends: criticalVar = 3
Thread [3] starts
Thread [3] ends: criticalVar = 4
Thread [4] starts
Thread [4] ends: criticalVar = 5
Thread [5] starts
Thread [5] ends: criticalVar = 6
Thread [6] starts
Thread [6] ends: criticalVar = 7
Thread [7] starts
Thread [7] ends: criticalVar = 8
Thread [8] starts
Thread [8] ends: criticalVar = 9
Thread [9] starts
Thread [9] ends: criticalVar = 10
Total time = 3.315000

Esta salida sólo tiene un problema: Total time. Con la adición del decorador, el script se comporta de forma secuencial en vez de paralela, pero eso es una efecto conocido de la seguridad de threads. En cualquier caso, el script corre correctamente, y eso es lo más importante.

Para más información sobre Threads y Decoradores.

Esto es todo por ahora . Los comentarios son bienvenidos.

from threading import Thread import time
import random

criticalVar = 0
threads = 10

class MyThread (Thread):

	def __init__ (self, id):
		Thread.__init__ (self)
		self.TID = id # Thread id

	def run (self):
		global criticalVar
		print 'Thread [%d] starts' % self.TID
		localVar = criticalVar + 1
		time.sleep (random.random ()) # Some long call between 0 and 1
		criticalVar = localVar
		print 'Thread [%d] ends: criticalVar = %d' % (self.TID, criticalVar)

if __name__ == '__main__':
	s = time.time ()
	threadBag = []
	for id in range (threads):
		t = MyThread (id)
		t.start ()
		threadBag.append (t)
	for thread in threadBag:
		thread.join ()
	print 'Total time = %f' % (time.time () - s)

This code shows a typical threading example. If you run this example it will show:

Thread [0] starts
Thread [1] starts
Thread [2] starts
Thread [3] starts
Thread [4] starts
Thread [5] starts
Thread [6] starts
Thread [7] starts
Thread [8] starts
Thread [9] starts
Thread [0] ends: criticalVar = 1
Thread [2] ends: criticalVar = 1
Thread [3] ends: criticalVar = 1
Thread [9] ends: criticalVar = 1
Thread [4] ends: criticalVar = 1
Thread [5] ends: criticalVar = 1
Thread [7] ends: criticalVar = 1
Thread [8] ends: criticalVar = 1
Thread [1] ends: criticalVar = 1
Thread [6] ends: criticalVar = 1
Total time = 0.872000

The output prints a pretty race-condition in the criticalVar because all threas reads the variable, make something time-consuming and then writes the variable. This behaviour leads to a failure because of the not thread-safety function run().

But, with a little decorator and some lock magic…

from threading import Thread, Lock
import time
import random

criticalVar = 0
threads = 10
myLock = Lock ()

def sync (lock):
	def function (f):
		def wrapper (*args, **kargs):
			lock.acquire ()
			try:
				return f(*args, **kargs)
			finally: # exec in all cases
				lock.release ()
		return wrapper
	return function

class MyThread (Thread):

	def __init__ (self, id):
		Thread.__init__ (self)
		self.TID = id # Thread id

	@sync (myLock)
	def run (self):
		global criticalVar
		print 'Thread [%d] starts' % self.TID
		localVar = criticalVar + 1
		time.sleep (random.random ()) # Some long call between 0 and 1
		criticalVar = localVar
		print 'Thread [%d] ends: criticalVar = %d' % (self.TID, criticalVar)

if __name__ == '__main__':
	s = time.time ()
	threadBag = []
	for id in range (threads):
		t = MyThread (id)
		t.start ()
		threadBag.append (t)
	for thread in threadBag:
		thread.join ()
	print 'Total time = %f' % (time.time () - s)

This is a thread-safe version. With the decorator at the begin of the run() function, each thread has to acquire the lock and release it when it finish. So, this decorator makes run() thread safe and the output is:

Thread [0] starts
Thread [0] ends: criticalVar = 1
Thread [1] starts
Thread [1] ends: criticalVar = 2
Thread [2] starts
Thread [2] ends: criticalVar = 3
Thread [3] starts
Thread [3] ends: criticalVar = 4
Thread [4] starts
Thread [4] ends: criticalVar = 5
Thread [5] starts
Thread [5] ends: criticalVar = 6
Thread [6] starts
Thread [6] ends: criticalVar = 7
Thread [7] starts
Thread [7] ends: criticalVar = 8
Thread [8] starts
Thread [8] ends: criticalVar = 9
Thread [9] starts
Thread [9] ends: criticalVar = 10
Total time = 3.315000

This output only has one problem: Total time. Since thread-safe decorator, script behaves sequential instead of parallel, but it’s a known effect of thread-safety. Any case, script runs correctly, and this is the most important thing.

For further information about Threads and Decorators.

This is all for now . Comments welcomed.

• random (): Genera un número flotante en el rango 0.0 <= x < 1.0.
• uniform (a, b): Genera un número flotante en el rango a<= x < b.
• randint (a, b): Genera un número entero en el rango a <= x <= b.

• randrange (a, b, paso): Selecciona un número entero en el rango dado. Este rango es igual al de la función built-in range(a, b, paso).

Y para continuar, funciones sobre secuencias:

• choice (secuencia): Devuelve un elemento de la secuencia.
• shuffle (secuencia): Altera el orden de los elementos en la misma secuencia (la misma referencia).
• sample (secuencia, n): Devuelve una nueva secuencia de longitud n con elemento de la secuencia.
• populate (secuencia, n): Lo mismo que sample, pero los elementos de la nueva secuencia no tienen repeticiones.

Para más información sobre el módulo random, visita este enlace.

Esto es todo por ahora. Mantente atento para más código interesante. Los comentarios siempre son bienvenidos.

• random (): Generate a float number in range 0.0 <= x < 1.0.
• uniform (a, b): Generate a float number in range a<= x < b.
• randint (a, b): Generate an integer number in range a <= x <= b.

• randrange (a, b, step): Select an integer number in a given range. This range is equal to built-in range (a, b, step).

And now, functions over sequences:

• choice (sequence): Return an element of the sequence.
• shuffle (sequence): Shuffle element of sequence in-place (the same sequence reference).
• sample (sequence, n): Return a new sequence of n length with elements from sequence.
• populate (sequence, n): The same as sample, but elements of new sequence don’t have repetitions.

For more information about random module, visit this.

This is all for now. Stay tuned for more interesting code snippets. Comments welcomed.

En lo tocante a python, hay una pequeña nota acerca de los threads a tener en cuenta. Los threads en python son simulados, es decir, si tienes 3 threads, realmente sólo existe uno, pero ése (el intérprete python) intercambia la ejecución de tus 3 threads de una manera planificada para simular el comportamiento de los threads. Por lo tanto, los threads de python se comportan como threads normales pero no son threads normales.

Vamos a ver un ejemplo simple…

from threading import Thread import time
import random

threads = 10

class MyThread (Thread):

	def __init__ (self, id):
		Thread.__init__ (self)
		self.TID = id # Thread id

	def run (self):
		print 'Thread [%d] starts' % self.TID
		time.sleep (random.random ()) # Some long call between 0 and 1
		print 'Thread [%d] ends' % self.TID
		self.status = random.randrange (10)

if __name__ == '__main__':
	s = time.time ()
	threadBag = []
	for id in range (threads):
		t = MyThread (id)
		t.start ()
		threadBag.append (t)
	for thread in threadBag:
		thread.join ()
		print 'Thread [%d] returned %d' % (thread.TID, thread.status)
	print 'Total time = %f' % (time.time () - s)

Este es un primer ejemplo sencillo utilizando threads en python. Cada thread es una instancia de una clase derivada de threading.Thread. Puedes ver que MyThread es esa clase. El método de ejecución es run (self) que es invocado desde la clase base. Debes poner todo el código del thread dentro de este método para ejecutarlo. El thread terminará al retorno de ese método. El otro método utilizado es __init__. Si necesitas pasar datos al thread, éste es tu métdo. Almacena todos los datos en variables de instancia (atributos) y disfruta! Para devolver un valor desde el thread, utiliza self.status y recupéralo cuando hagas el join () del thread.

El ejemplo sencillo crea algunos threads, los lanza (con el método start()) y después los reúne para recuperar su estado de salida. También calcula el tiempo necesario para todo el script. La salida (variable, debido al uso del módulo random) es:

Thread [0] starts
Thread [1] starts
Thread [2] starts
Thread [3] starts
Thread [4] starts
Thread [5] starts
Thread [6] starts
Thread [7] starts
Thread [8] starts
Thread [9] starts
Thread [0] ends
Thread [0] returned 2
Thread [3] ends
Thread [5] ends
Thread [1] ends
Thread [1] returned 7
Thread [6] ends
Thread [9] ends
Thread [4] ends
Thread [7] ends
Thread [2] ends
Thread [2] returned 2
Thread [3] returned 2
Thread [4] returned 5
Thread [5] returned 3
Thread [6] returned 2
Thread [7] returned 5
Thread [8] ends
Thread [8] returned 2
Thread [9] returned 6
Total time = 0.861000

Fíjate en los ‘ends’ de los threads, ya que la creación y reunión de los threads son bucles secuenciales, por lo que siempre saldrán en orden. Puedes ver que los threads necesitan diferentes tiempos para terminar. Pero la magía consiste en que el tiempo total de todo el script es, más o menos, el máximo de los tiempos aleatorios, así que ¡La ejecución es paralela!!!

Para más información sobre threads, visita este link.

Por ahora es todo. Cualquier comentario es bienvenido.

Concerning python, there’s a tip that you have to have in mind. In python, threads are simulated, I mean, when you have 3 threads, really there’s only one, but that one (the python interpreter) swaps between your 3 threads in a scheduled manner to simulate threads behaviour. So, python threads behaves as normal threads but they’re not normal threads.

Let’s go to see the example…

from threading import Thread import time
import random

threads = 10

class MyThread (Thread):

	def __init__ (self, id):
		Thread.__init__ (self)
		self.TID = id # Thread id

	def run (self):
		print 'Thread [%d] starts' % self.TID
		time.sleep (random.random ()) # Some long call between 0 and 1
		print 'Thread [%d] ends' % self.TID
		self.status = random.randrange (10)

if __name__ == '__main__':
	s = time.time ()
	threadBag = []
	for id in range (threads):
		t = MyThread (id)
		t.start ()
		threadBag.append (t)
	for thread in threadBag:
		thread.join ()
		print 'Thread [%d] returned %d' % (thread.TID, thread.status)
	print 'Total time = %f' % (time.time () - s)

This a simple first example of using threads in python. Every thread in python is an instance of a derived class of threading.Thread. You can see that class MyThread is that class. The method of execution is run (self) that is invoked by the base class. You have to put all your thread’s code into that method in order to execute it. Thread will end when this method return. The other method to override is __init__. If you want to pass some data to the thread, this is your method. Save all the data in instance’s variables and enjoy! To return a value from thread, use self.status and recover it in join () call.

The example simply creates some threads, launch them (with start() method) and then join them to recover their exit status. Also calculates the time needed for all the script. The (variable, because I use random module) output is:

Thread [0] starts
Thread [1] starts
Thread [2] starts
Thread [3] starts
Thread [4] starts
Thread [5] starts
Thread [6] starts
Thread [7] starts
Thread [8] starts
Thread [9] starts
Thread [0] ends
Thread [0] returned 2
Thread [3] ends
Thread [5] ends
Thread [1] ends
Thread [1] returned 7
Thread [6] ends
Thread [9] ends
Thread [4] ends
Thread [7] ends
Thread [2] ends
Thread [2] returned 2
Thread [3] returned 2
Thread [4] returned 5
Thread [5] returned 3
Thread [6] returned 2
Thread [7] returned 5
Thread [8] ends
Thread [8] returned 2
Thread [9] returned 6
Total time = 0.861000

You only have to focus on ‘ends’ of threads, because creation and joining are sequential loops. You can see each thread needs a different time to end. But the magic here is that the total amount of time of the whole script is, more or less, the maximum of the random time values, so execution is parallel!!!

For more information about threads, visit this.

This is all for now. Comments welcomed!