Manufaturação industrial
Internet das coisas industrial | Materiais industriais | Manutenção e reparo de equipamentos | Programação industrial |
home  MfgRobots >> Manufaturação industrial >  >> Industrial programming >> python

Python - Programação Multithread

Página anteriorPróxima página
Executar vários threads é semelhante a executar vários programas diferentes simultaneamente, mas com os seguintes benefícios -

  • Vários threads em um processo compartilham o mesmo espaço de dados com o thread principal e podem, portanto, compartilhar informações ou comunicar-se uns com os outros mais facilmente do que se fossem processos separados.

  • Threads às vezes chamados de processos leves e não requerem muita sobrecarga de memória; eles são mais baratos do que processos.

Um thread tem um início, uma sequência de execução e uma conclusão. Ele tem um ponteiro de instrução que mantém o controle de onde dentro do contexto ele está sendo executado no momento.

  • Pode ser antecipado (interrompido)

  • Ele pode ser temporariamente colocado em espera (também conhecido como hibernação) enquanto outros threads estão em execução - isso é chamado de rendição.

Iniciando um novo tópico


Para gerar outro tópico, você precisa chamar o seguinte método disponível no tópico módulo -
 thread.start_new_thread (function, args [, kwargs]) 

Essa chamada de método permite uma maneira rápida e eficiente de criar novos threads no Linux e no Windows.

A chamada do método retorna imediatamente e o thread filho inicia e chama a função com a lista passada de args . Quando a função retorna, o thread termina.

Aqui, args é uma tupla de argumentos; use uma tupla vazia para chamar a função sem passar nenhum argumento. kwargs é um dicionário opcional de argumentos de palavras-chave.

Exemplo

 #! / usr / bin / pythonimport threadimport time # Defina uma função para threaddef print_time (threadName, delay):count =0 while count <5:time.sleep (delay) count + =1 print "% s:% s"% (threadName, time.ctime (time.time ())) # Crie dois threads como a seguir:thread.start_new_thread (print_time, ("Thread-1", 2,)) thread. start_new_thread (print_time, ("Thread-2", 4,)) exceto:print "Erro:não foi possível iniciar o thread" enquanto 1:passou 

Quando o código acima é executado, ele produz o seguinte resultado -
 Tópico 1:Qui, 22 de janeiro 15:42:17 2009Thread-1:Qui, 22 de janeiro 15:42:19 2009Thread-2:Qui, 22 de janeiro 15:42:19 2009Thread-1:Qui 22 de janeiro 15:42:21 2009Thread-2:Qui 22 Jan 15:42:23 2009Thread-1:Qui 22 Jan 15:42:23 2009Thread-1:Qui 22 Jan 15:42:25 2009Thread-2:Qui 22 Jan 15:42:27 2009Thread-2:Thu Jan 22 15:42:31 2009 Thread-2:Thu Jan 22 15:42:35 2009 

Embora seja muito eficaz para threading de baixo nível, mas o thread módulo é muito limitado em comparação com o módulo de threading mais recente.

O Threading Módulo


O módulo de threading mais recente incluído no Python 2.4 oferece suporte de alto nível muito mais poderoso para threads do que o módulo de thread discutido na seção anterior.

O threading módulo expõe todos os métodos do thread módulo e fornece alguns métodos adicionais -

  • threading.activeCount () - Retorna o número de objetos de thread que estão ativos.

  • threading.currentThread () - Retorna o número de objetos de thread no controle de thread do chamador.

  • threading.enumerate () - Retorna uma lista de todos os objetos de thread que estão atualmente ativos.

Além dos métodos, o módulo de threading possui o Thread classe que implementa threading. Os métodos fornecidos pelo Thread classe são as seguintes -

  • correr () - O método run () é o ponto de entrada para um thread.

  • iniciar () - O método start () inicia um thread chamando o método run.

  • entrar ([tempo]) - O join () espera que os encadeamentos sejam encerrados.

  • isAlive () - O método isAlive () verifica se uma thread ainda está em execução.

  • getName () - O método getName () retorna o nome de um thread.

  • setName () - O método setName () define o nome de um thread.

Criação de rosca usando rosca Módulo


Para implementar um novo thread usando o módulo de threading, você deve fazer o seguinte -

  • Defina uma nova subclasse de Thread classe.

  • Substitua o __init __ (self [, args]) método para adicionar argumentos adicionais.

  • Em seguida, substitua o método run (self [, args]) para implementar o que o thread deve fazer quando iniciado.

Depois de criar o novo Tópico subclasse, você pode criar uma instância dela e, em seguida, iniciar um novo encadeamento invocando o start () , que por sua vez chama run () método.

Exemplo

 #! / usr / bin / pythonimport threadingimport timeexitFlag =0class myThread (threading.Thread):def __init __ (self, threadID, name, counter):threading.Thread .__ init __ (self) self. threadID =threadID self.name =name self.counter =counter def run (self):print "Iniciando" + self.name print_time (self.name, 5, self.counter) print "Saindo" + self.namedef print_time (threadName , counter, delay):while counter:if exitFlag:threadName.exit () time.sleep (delay) print "% s:% s"% (threadName, time.ctime (time.time ())) counter - =1 # Create new threadsthread1 =myThread (1, "Thread-1", 1) thread2 =myThread (2, "Thread-2", 2) # Start new Threadsthread1.start () thread2.start () print "Saindo do thread principal" 

Quando o código acima é executado, ele produz o seguinte resultado -
 Iniciando Thread-1Starting Thread-2Exiting Main ThreadThread-1:Thu Mar 21 09:10:03 2013Thread-1:Thu Mar 21 09:10:04 2013Thread-2:Thu Mar 21 09:10:04 2013Thread-1:Qui 21 Mar 09:10:05 2013Thread-1:Qui 21 Mar 09:10:06 2013Thread-2:Qui 21 Mar 09:10:06 2013Thread-1:Qui 21 Mar 09:10:07 2013Exiting Thread-1Thread-2:Thu Mar 21 09:10:08 2013Thread-2:Thu Mar 21 09:10:10 2013Thread-2:Thu Mar 21 09:10:12 2013Exiting Thread-2 

Sincronizando Threads


O módulo de threading fornecido com Python inclui um mecanismo de bloqueio simples de implementar que permite sincronizar threads. Um novo bloqueio é criado chamando o Lock () método, que retorna o novo bloqueio.

O adquirir (bloquear) método do novo objeto de bloqueio é usado para forçar a execução de threads de forma síncrona. O bloqueio opcional O parâmetro permite que você controle se o encadeamento espera para adquirir o bloqueio.

Se bloqueando é definido como 0, o encadeamento retorna imediatamente com um valor 0 se o bloqueio não pode ser adquirido e com 1 se o bloqueio foi adquirido. Se o bloqueio for definido como 1, o thread bloqueia e espera que o bloqueio seja liberado.

O lançamento () O método do novo objeto de bloqueio é usado para liberar o bloqueio quando ele não for mais necessário.

Exemplo

 #! / usr / bin / pythonimport threadingimport timeclass myThread (threading.Thread):def __init __ (self, threadID, name, counter):threading.Thread .__ init __ (self) self.threadID =threadID self.name =name self.counter =counter def run (self):print "Iniciando" + self.name # Obtenha bloqueio para sincronizar threads threadLock.acquire () print_time (self.name, self.counter, 3) # Free lock para liberar o próximo thread threadLock.release () def print_time (threadName, delay, counter):while counter:time.sleep (delay) print "% s:% s"% (threadName, time.ctime (time.time () )) counter - =1threadLock =threading.Lock () threads =[] # Criar novo threadsthread1 =myThread (1, "Thread-1", 1) thread2 =myThread (2, "Thread-2", 2) # Começar novo Threadsthread1.start () thread2.start () # Adicionar tópicos ao tópico listthreads.append (thread1) threads.append (thread2) # Aguarde que todos os tópicos sejam concluídos para t nos tópicos:t.join () print "Saindo do Tópico Principal" 

Quando o código acima é executado, ele produz o seguinte resultado -
 Iniciando Thread-1Starting Thread-2Thread-1:Thu Mar 21 09:11:28 2013Thread-1:Thu Mar 21 09:11:29 2013Thread-1:Thu Mar 21 09:11:30 2013Thread-2:Qui 21 Mar 09:11:32 2013Thread-2:Qui 21 Mar 09:11:34 2013Thread-2:Qui 21 Mar 09:11:36 2013 Saindo do Tópico Principal 

Fila prioritária multithread


A fila O módulo permite criar um novo objeto de fila que pode conter um número específico de itens. Existem métodos a seguir para controlar a fila -

  • get () - O get () remove e retorna um item da fila.

  • colocar () - A colocação adiciona o item a uma fila.

  • qsize () - O qsize () retorna o número de itens que estão atualmente na fila.

  • vazio () - O empty () retorna True se a fila estiver vazia; caso contrário, False.

  • cheio () - o full () retorna True se a fila estiver cheia; caso contrário, False.

Exemplo

 #! / usr / bin / pythonimport Queueimport threadingimport timeexitFlag =0class myThread (threading.Thread):def __init __ (self, threadID, name, q):threading.Thread .__ init __ (self) self .threadID =threadID self.name =name self.q =q def run (self):print "Iniciando" + self.name process_data (self.name, self.q) print "Saindo" + self.namedef process_data (threadName, q):enquanto não exitFlag:queueLock.acquire () se não workQueue.empty ():data =q.get () queueLock.release () print "% s processando% s"% (threadName, dados) else:queueLock. release () time.sleep (1) threadList =["Thread-1", "Thread-2", "Thread-3"] nameList =["One", "Two", "Three", "Four", " Five "] queueLock =threading.Lock () workQueue =Queue.Queue (10) threads =[] threadID =1 # Criar novos threads para tName em threadList:thread =myThread (threadID, tName, workQueue) thread.start () threads. append (thread) threadID + =1 # Preencha o queuequeueLock.acquire () para a palavra em nameList:workQueue.put (word) queueLock.releas e () # Espera que a fila se esvazie antes de trabalharQueue.empty ():pass # Notificar os tópicos que é hora de exitexitFlag =1 # Esperar que todos os tópicos sejam concluídos:t.join () print "Saindo do Tópico Principal"  
Quando o código acima é executado, ele produz o seguinte resultado -
 Iniciando Thread-1Starting Thread-2Starting Thread-3Thread-1 processando OneThread-2 processando TwoThread-3 processando ThreeThread-1 processando FourThread-2 processando FiveExiting Thread-3Exiting Thread-1Exiting Thread-2Exiting Main Thread 

python

  1. Python - Tratamento de exceções
  2. Herança múltipla do Python
  3. Decoradores Python
  4. Função principal e método do Python Exemplo:Understand def Main ()
  5. Operadores Python
  6. Tutorial PyUnit:Framework de teste de unidade Python (com exemplo)