Obtenga un valor de retorno de un hilo en Python

1. Programa HelloWorld utilizando subprocesos múltiples en Python
2. Obtener un valor de retorno de una función que se ejecuta en hilo en Python

Este artículo primero discutirá los conceptos básicos de los hilos y un código para iniciar un hilo en Python. Después de esto, discutiremos un código para obtener el retorno de valor de una función que se ejecuta en un hilo.

Un subproceso es una unidad de ejecución ligera dentro de un proceso con sus propios estados de ejecución del programa. Un proceso ejecuta varios subprocesos para lograr la concurrencia (y, a veces, el paralelismo).

La principal diferencia entre un proceso y un subproceso es que cada proceso tiene un espacio de direcciones separado e independiente, mientras que varios subprocesos del mismo proceso comparten el mismo espacio de direcciones de un solo proceso. Esto significa que los subprocesos pueden comunicarse utilizando la memoria compartida sin necesidad de canalizaciones adicionales (canalizaciones ordinarias o FIFO) o cualquier interfaz de paso de mensajes.

Programa HelloWorld utilizando subprocesos múltiples en Python

Considere el siguiente código:

from threading import Thread

# A function for threads.


def first_function():
    print("Hello World")


print("main program start")

thread_1 = Thread(target=first_function)
thread_2 = Thread(target=first_function)
thread_1.start()
thread_2.start()

print("main ends")

En el código anterior, primero, usamos la instrucción from threading import Thread para importar la clase Thread para usar el multi-threading. Definimos una función first_function() que muestra Hello World, y usamos la clase Thread() para instanciar los hilos.

Creamos dos instancias de la clase Thread() pasando first_function() como una función objetivo para ejecutar. El atributo target especifica la función a ejecutar por el Thread().

Una vez que se crean las instancias de Thread(), podemos ejecutar y ejecutar estos hilos usando el método .start().

Pasar argumentos a una función que se ejecuta en un subproceso

Considere el siguiente código:

from threading import Thread


def first_function(name, id):
    print("Hello World from ", name, " ID= ", id)


thread_1 = Thread(target=first_function, args=("Thread 1", 1))
thread_2 = Thread(target=first_function, args=("Thread 2", 2))
thread_1.start()
thread_2.start()

En el código anterior, definimos la función first_function(name, id), recibiendo dos argumentos, name e id. Pasamos estos argumentos como una tupla usando args en la clase Thread.

Creamos dos objetos de clase Thread y pasamos los argumentos args=("Thread 1", 1) y args=("Thread 2", 2) a thread_1 y thread_2 respectivamente. Además, thread_1.start() y thread_2.start() se utilizan para ejecutar estos hilos.

Obtener un valor de retorno de una función que se ejecuta en hilo en Python

Hay diferentes formas de obtener un valor de retorno de una función que se ejecuta en un hilo.

Pasar un objeto mutable a la función

Podemos obtener un valor de una función que se ejecuta en un hilo pasando un objeto mutable a la función; la función coloca el valor devuelto en ese objeto. Considere el siguiente código:

from threading import Thread


def first_function(first_argu, return_val):
    print(first_argu)
    return_val[0] = "Return Value from " + first_argu


return_val_from_1 = [None] * 1
return_val_from_2 = [None] * 1

thread_1 = Thread(target=first_function, args=("Thread 1", return_val_from_1))
thread_2 = Thread(target=first_function, args=("Thread 2", return_val_from_2))

thread_1.start()
thread_2.start()

thread_1.join()
thread_2.join()

print(return_val_from_1)
print(return_val_from_2)

El código anterior define una función first_function que recibe dos argumentos: first_argu y return_val. La first_function muestra el valor de first_argu y coloca el valor de retorno en los índices 0 de return_val.

Creamos un hilo usando la clase Thread y pasamos dos argumentos que incluyen una lista args=("Thread 1", return_val_from_1) y args=("Thread 2", return_val_from_2) para thread_1 y thread_2 respectivamente. return_val_from_1 y return_val_from_2 se utilizan para obtener el valor de la función.

thread_1.join() y thread_2.join() se utilizan para esperar a que el programa principal complete ambos hilos.

Veamos el resultado del fragmento de código anterior:

Utilice el método unirse

El método join es otra forma de obtener un valor de retorno de una función que se ejecuta en un hilo. Considere el siguiente código:

from threading import Thread


def first_function(first_argu):
    print(first_argu)
    return "Return Value from " + first_argu


class NewThread(Thread):
    def __init__(self, group=None, target=None, name=None, args=(), kwargs={}):
        Thread.__init__(self, group, target, name, args, kwargs)

    def run(self):
        if self._target != None:
            self._return = self._target(*self._args, **self._kwargs)

    def join(self, *args):
        Thread.join(self, *args)
        return self._return


thread_1 = NewThread(target=first_function, args=("Thread 1",))
thread_2 = NewThread(target=first_function, args=("Thread 2",))

thread_1.start()
thread_2.start()

print(thread_1.join())
print(thread_2.join())

En el código anterior, definimos una clase personalizada, NewThread, una subclase de la clase Thread. Redefinimos los métodos run y join.

Una vez que creamos un hilo y comenzamos, el valor de retorno de first_function se devuelve desde el método join().

La salida del siguiente código es la siguiente: