Python Thread Lock
Exemplo # 1: Execução do script de thread python utilizando tempo limite em adquirir () bloqueio.
Discutiremos o uso do método "adquirir ()" da trava neste exemplo. O método "adquirir ()" pode ser usado para travar. Não podem ser feitos mais esforços para conseguir isso até que a fechadura seja liberada assim que um thread for bloqueado. O método "adquirir ()" pode ser usado para proteger um bloqueio. Uma vez que um tópico garantiu a fechadura, nenhuma outra tentativa pode ser feita para fazê -lo até que a fechadura seja liberada. A opção "Timeout" também será usada nesta instância do método "adquirir ()" para especificar quanto tempo o encadeamento de chamada será adiado se outra operação já estiver tentando obter o bloqueio. Se o valor potencial do fio for 1, que for 1, o fio será atrasado indefinidamente até adquirir a trava. Aqui, usamos isso para determinar quanto tempo um tópico procurará uma trava.
Vamos começar a implementar o script usando a ferramenta "Spyder" para implementar o código. Vamos importar o bloqueio e o thread da biblioteca Python Threading First. Os threads são utilizados em um processo python para realizar a execução do código. Cada programa possui um tópico por padrão, mas talvez precisamos produzir mais threads, se quisermos fazer vários processos simultaneamente. O módulo de sono é então importado. O método "Sleep ()" no módulo de tempo de Python é usado para pausar a execução de um programa por uma quantidade predeterminada de tempo. Isso sugere que o programa está temporariamente suspenso antes de ser executado automaticamente após um período predeterminado. Em seguida, o método "Lock ()" é usado. Então, na linha a seguir, definimos uma função com o nome "func1" e passamos a variável "Lock" em seus parênteses.
A declaração "se" permite a execução de uma declaração ou conjunto de declarações em circunstâncias específicas com base no resultado de uma expressão. Usamos o método "adquirir ()" no objeto de bloqueio dentro da condição "se" para que o fio espere continuamente pela fechadura. Passamos um tempo limite como um de seus parâmetros e o definimos como "10" nos parênteses da função "adquirir ()". Agora, se a declaração atende ao requisito, usamos a função "print ()", passando a declaração "Thread 2: Coned" em seus parênteses e depois chamamos o método Release () em um módulo de objeto de bloqueio. Se o bloqueio estiver bloqueado, esse processo reagirá depois de revertê -lo ao seu estado desbloqueado.
Além disso, esse método pode ser chamado por qualquer tópico. É permitido para um dos threads que já estão esperando para adquirir o porão para se apegar a ele até que essa função seja chamada. Agora imprimimos a declaração "Tópico 1: Tempo limite" se a condição não for atendida. Agora criaremos uma nova função com o nome "func" e o parâmetro bloqueado na linha a seguir. Em seguida, usando o objeto de bloqueio, executamos o método "adquirir ()". Na linha a seguir, chamamos a função "print ()" e fornecemos a declaração "Thread 1: Coned" antes de usar o método "Release ()" com o bloqueio.
Agora criaremos um tópico e chamamos os métodos do thread chamando o objeto Thread. Usamos um tópico e definimos "Target = func" dentro dele, passando o argumento "trava",. Em seguida, salvamos este tópico em uma variável chamada “Thread1."Na próxima linha, chamamos" func1 "com o thread e passamos o argumento" Lock ", usando" Thread1.start () ”para iniciar o tópico. Fizemos o mesmo para Thread2. O método "junção ()" é então usado para aguardar a execução de threads. Assim, temos dois fios, cada um dos quais chama duas rotinas distintas. O tempo limite para o segundo tópico é "10" segundos, enquanto o primeiro tópico funciona por "2" segundos.
A tela de saída agora mostra que o encadeamento 1 é feito primeiro desde que foi gerado primeiro e conseguiu acessar o bloqueio e terminar sua execução. O tópico 2 está terminado porque o tempo limite foi definido como "10" segundos, como pode ser visto.
Exemplo # 2: Usando o bloqueio do fio do Python em uma condição de corrida
Usaremos o bloqueio do thread python em uma condição de corrida neste exemplo. Uma condição de corrida ocorre quando dois fios olham para uma variável compartilhada, simultaneamente, momento. Os threads iniciais e segundos receberam o mesmo resultado da constante do tópico original. Então, os dois fios tentam alterar o valor comum da variável dependente. Os dados do encadeamento que adicionam à lista de variáveis compartilhados são mantidos porque apaga o valor que o tópico anterior escreveu.
Vamos começar a implementar o código. Na primeira linha, importamos o módulo de bloqueio do módulo de rosqueamento. E na linha seguinte, importamos o módulo de tempo. Em seguida, criamos uma variável e damos o valor "20". Na próxima linha, criamos uma função chamada "func1" e passamos duas variáveis "increment" e "bloqueio" como seus parâmetros. Criamos uma variável global chamada "A" e passamos uma trava.
Finalmente, na linha seguinte, criamos uma variável chamada “Local_counter” e a passamos para ela. O valor desse "contador local" é incrementado na próxima linha, dependendo de qual thread termina último. Então, chamamos o “tempo.Sleep () ”” e forneça um período de “0.5 ”segundos na linha seguinte. O método "print ()" é então executado e o contador local é salvo na variável "a". Dentro desta função, o encadeamento atual é chamado usando "Threading.current_thread ().incrementos de nome A por incremento "e passa o" a "no qual o valor é armazenado e o método" liberação () "com bloqueio é chamado na linha a seguir. Na próxima linha, passamos o método Lock ().
Agora, vamos criar dois tópicos e chamar a função usando os threads. Chamamos a função no primeiro tópico usando rosqueamento.Thread, usado "Target = func1", e passe o argumento "15" como seu incremento e "bloqueio". Armazenamos este primeiro tópico na variável "T1" e depois repetimos o mesmo procedimento para o thread 2, mas passamos o argumento que é o incremento de "5" e "Lock". Então, usamos “thread.start () "para iniciar o tópico e" ingressar () "para aguardar o tópico terminar em execução. O valor final será exibido.
Agora, basta colocar este código faz com que ambos os threads leiam o valor que compartilhamos. "T1" e "T2" tentarão alterar o valor de "A" na função de incremento usando os valores de incremento "15" e "5" que são fornecidos no parâmetro Tuple.
Agora, ele exibe o resultado final "40" na saída. Como temos "A = 20" no código acima, quando "Thread 1" aumenta em "15", o resultado é "35" e o valor muda para "35", no entanto, quando "Thread 2" aumenta por "5" O resultado é "40".
Conclusão
A função Python Thread Lock, que possui dois métodos: adquirir () e release () é abordada neste artigo. Dois exemplos são apresentados neste guia. Em primeira instância, usamos um tempo limite em um bloqueio adquirir () e, no segundo exemplo, usamos uma condição de corrida usando o python Lock () para mostrar como isso afeta como os threads operam. Prevemos que você achará esses casos úteis quando usar os bloqueios de threads python.