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

Anúncios

6 Respostas to “Threads em python”

  1. ubiratã uaatsim itzá I Says:

    muito bom este seu material, valeu pelas dicas!

  2. Como faço para saber se a thread terminou ou não ?
    Estou com dificuldades em saber quando terminei para só então mostrar os resultados obtidos

  3. Gostei do texto. Uma ótima introdução ao assunto.

  4. Interessante. Obrigado por compartilhar!
    Abraço.

  5. Olá, estava estudando sobre threads e seu post ajudou, valeu por compartilhar. Acabei escrevendo um post sobre o assunto no meu blog ( http://techaffairs.com.br/threads-em-python/ ).

  6. Muito bom seu Material!!! éra tudo que eu estava precisando.
    Muito obrigado.
    Carlos

Deixe um comentário

Preencha os seus dados abaixo ou clique em um ícone para log in:

Logotipo do WordPress.com

Você está comentando utilizando sua conta WordPress.com. Sair / Alterar )

Imagem do Twitter

Você está comentando utilizando sua conta Twitter. Sair / Alterar )

Foto do Facebook

Você está comentando utilizando sua conta Facebook. Sair / Alterar )

Foto do Google+

Você está comentando utilizando sua conta Google+. Sair / Alterar )

Conectando a %s

%d blogueiros gostam disto: