Threads em python

Neste artigo vamos falar de Threads em Python. Antes de começar, preciso avisar que estou escrevendo enquanto pesquiso sobre o tema. Não atribua a este artigo autoridade maior do que ele merece. O objetivo dele é compartilhar o aprendizado do autor. Isto significa que o que é mostrado aqui está correto, mas não te dispensa de pesquisar em outras fontes.

Feitas as ressalvas, voltemos ao tema.

Explicando de forma grosseira, thread é uma forma de você não deixar seu programa ‘travar’ enquanto executa uma tarefa demorada. Usando thread, voce pode colocar essa tarefa para correr em paralelo, enquanto seu código segue; como uma bifurcação, mas dentro do mesmo processo, compartilhando o mesmo espaço de programa, como as variáveis e tudo o mais.

Há duas formas de você adicionar funcionalidades de threads ao seu código: com o módulo thread ou com a classe threading.Thread.

Com o módulo thread, você chama o método thread.start_new_thread(func, args), onde func é a função que você escreveu e que vai ser executada pela thread, e args é um tupla com os argumentos para a sua função.

O módulo threading é uma ‘extensão’ do módulo thread. Ele implementa a classe Thread e, entre outros, seu método start(). O método start() vai (não diretamente) chamar o método run() com start_new_thread(). Há também mais de uma forma de usar threading.Thread:

• criando uma instância de threading.Thread() ou

• criando uma classe que herda de threading.Thread e sobrescrevendo o método run().

Na primeira forma:

from threading import Thread
def minha_funcao(algumacoisa):
    print algumacoisa

th=Thread( target=minha_funcao, args = ( 'qualquercoisa', ) )
th.start()

O construtor de Thread recebe, além de self, 6 argumentos (referência aqui), e entre eles:

• group: Deve ser sempre None, é reservado para uso em uma futura classe ThreadGroup;

• target: o método ou função que vai ser chamado em run();

• args: uma tupla com os argumentos que serão passados para a função em target.

Veja trecho do código de threading.py, localizado no meu sistema em /usr/lib/python2.5 .

Para ver onde fica o arquivo no seu sistema, veja o valor de threading.__file__

class Thread(_Verbose):

    __initialized = False
    # Need to store a reference to sys.exc_info for printing
    # out exceptions when a thread tries to use a global var. during interp.
    # shutdown and thus raises an exception about trying to perform some
    # operation on/with a NoneType
    __exc_info = _sys.exc_info

    def __init__(self, group=None, target=None, name=None,
                 args=(), kwargs=None, verbose=None):
        assert group is None, "group argument must be None for now"
        _Verbose.__init__(self, verbose)
        if kwargs is None:
            kwargs = {}
        self.__target = target
        self.__name = str(name or _newname())
        self.__args = args
        self.__kwargs = kwargs
        self.__daemonic = self._set_daemon()
        self.__started = False
        self.__stopped = False
        self.__block = Condition(Lock())
        self.__initialized = True
        # sys.stderr is not stored in the class like
        # sys.exc_info since it can be changed between instances
        self.__stderr = _sys.stderr

Na segunda forma (herdando de threading.Thread), somente os métodos __init__() e run() podem ser sobrescritos.

# -.- coding: utf-8 -.-
from threading import Thread

class minhaThread(Thread):
    # sobrescrevendo o método __init__()
    def __init__(self, meu_argumento):
        # o metodo __init__ da superclasse
        # deve ser chamado para proceder
        # com a inicialização
        Thread.__init__(self)
        self.atributo=meu_argumento

    # sobrescrevendo o metodo run()
    def run(self):
        #insira seu codigo aqui
        print 'patata'

Para executar a thread, você cria uma instância de minhaThread() e chama o método minhaThread.start().

thr = minhaThread( 'algum argumento' )
thr.start()

Não estenderemos por agora o artigo, e não haverá aqui nenhum exemplo “funcional” de utilização de threads.

Por enquanto, ficam as referências de pesquisa:

Understanding Threading in Python

Using threads in PyGTK

Python Library Reference – 15.3.6 Thread Objects