Trava multiprocessante em Python

O pacote multiprocessamento do Python permite que os usuários criem novos processos e acessem a API Python. Se você já brincou com o módulo de rosqueamento, isso é muito comparável. O desempenho de múltiplas tarefas é necessário. Devemos importar o módulo multiprocessamento no script python para fazer operações de multiprocessamento. Quando dois processos ou tópicos tentam acessar um recurso compartilhado, como arquivos de memória ou outros dados, isso pode causar problemas no mundo da programação. Assim, precisamos garantir esse acesso usando um bloqueio. Compartilhar a memória e acessórios principais permitem que as unidades de processamento executem os programas simultaneamente.

O aplicativo multiprocessamento se divide em unidades menores e opera separadamente. O sistema operacional atribui um processador a cada processo. Para impedir que outro processo execute uma função equivalente até que a trava seja liberada, utilizamos a classe de bloqueio multiprocessante para obter uma trava no processo. A classe de bloqueio realiza principalmente duas funções. O método adquirir () é usado para primeiro obter um bloqueio, enquanto a função Release () é usada para liberar o bloqueio.

Implementação do Lock () por Python no multiprocessamento

Neste exemplo, construímos um bloqueio e depois usamos o módulo multiprocessamento para usar o método Lock () após criar dois processos. Podemos gerar e manter as novas tarefas da criança em Python, utilizando o pacote multiprocessante. O componente multiprocessante facilita a criação dos processos usando uma interface semelhante ao componente de rosqueamento. O módulo multiprocessamento suporta simultaneidade local e global usando peças individuais em vez de threads, eliminando o bloqueio de interpretação global. O Python tem uma trava mutex que pode ser usada com vários processos de uma só vez.trava da aula. Os processos podem construir, adquirir e depois liberar um objeto do bloqueio antes de acessar uma área vital.

Vamos agora começar a implementar o código para executar o script multiprocessante do Python. "Spyder" também está sendo usado. Nós importamos o módulo multiprocessamento primeiro. Devemos importar o módulo multiprocessamento, pois devemos criar um processo no script. Depois disso, construímos uma função definida pelo usuário chamada "função" e passamos o argumento "Lock" na linha que segue. O método adquirir () é então chamado com a frase "bloqueio", que fornece uma autoridade de fio acima de um bloqueio. Um thread bloqueia até que o outro tópico caia a trava, se tentar adquirir um que já está sendo mantido por outro tópico. Naquele momento, compete com todos os outros tópicos que buscam aproveitar a fechadura. Um tópico de cada vez pode possuir apenas a fechadura. A declaração de "seção importante" é então passada como entrada quando chamamos de "print ()" na seguinte etapa.

Então, na etapa subsequente, chamamos a função "print ()" mais uma vez, passando a frase "pode ​​haver apenas um processo de cada vez" antes de chamar a função "Release ()" com o "Lock". Quando feito dessa maneira, o bloqueio é sempre liberado, mesmo que haja um bug ou erro na região crucial, definindo claramente o início e o fim do código protegido.

Agora que definimos uma função com o nome "Função Run", continuamos para a próxima fase em que criamos um processo e depois o chamamos usando o módulo "Lock ()". Mantemos no parâmetro de bloqueio e usamos “multiprocessamento.Lock () ”para chamar o bloqueio com o processo. Agora que criamos o processo 1, usamos “multiprocessamento.processo ”para chamar a função nesse processo. Também passamos o argumento bloqueado para a função usando a "argu" = "bloqueio" e armazenando o processo 1 na variável "p1".

Então, na etapa seguinte, usamos “multiprocessamento.processo ”para executar a função no processo 2 e passar no“ Target = function ”enquanto o armazena na variável“ P2 ”. O processo é então iniciado usando a função "start ()" com "P1" e "P2". Na próxima etapa, usamos "junção ()" com "P1" e "P2" para esperar a execução do processo ser concluída. Em seguida, empregamos o "se nome = main_", que é essencialmente um ponto de entrada. O "function run ()" é então invocado no final.

Para conseguir isso, o processo deve primeiro adquirir o bloqueio antes de executar a parte essencial. Quando a fase crítica da tarefa é concluída, o processo deve remover o bloqueio. Os dois processos e suas declarações foram exibidos. Só poderia haver uma única tarefa em execução por vez apresentada após a “seção crítica.”

Agora temos outro exemplo de bloqueio multiprocessante em Python. Vamos começar importando “sono” do módulo de tempo antes de importar “aleatório” do módulo aleatório. Os números inteiros são gerados aleatoriamente usando um programa Python chamado Python Random. Por serem pseudo-aleatórios, esses números não são verdadeiramente aleatórios. Você pode usar este pacote para executar outras operações aleatórias, imprimir um número aleatório para uma lista ou string e gerar os números aleatórios.

Em seguida, importamos o processo do multiprocessamento na linha a seguir. A fechadura é então importada do multiprocessamento. A função "func" é então definida com os argumentos "Lock", "Identifier" e "Val" que estão sendo aprovados. Em seguida, usamos uma fechadura para obter a fechadura. Esta parte crucial implica relatar uma mensagem e bloquear uma segunda mensagem.

Como resultado, executamos o método print () dentro da fechadura, passando a declaração junto com as chamadas "Identificador" e "Val". O método "Sleep ()" é usado para pausar a execução para um número definido de segundos. Em seguida, chamamos de "val" dentro de seus parênteses. O bloqueio compartilhado é estabelecido usando o método "Lock ()" e salvo na variável "Lock" recém -criada quando utilizamos a condição "se nome = main_". Em seguida, usamos o método Process () para criar um processo, passando o "Target = func" para chamar a função para o processo junto com o argumento "Lock", o número construído "X" e o "Random ()" função. Este loop termina após a conclusão de suas iterações “15”. Salvamos esse processo na variável "P".

Aqui, também estabelecemos o intervalo usando "para" e definindo o intervalo para "15". O processo agora começa chamando o "processo.começar()". Em seguida, chamamos o processo com o método "junção ()" para aguardar a execução.

Quando o exemplo é executado, quinze processos são iniciados e cada um é configurado para usar nossa função personalizada. Depois disso, o processo principal espera que cada um dos processos da criança seja concluído antes de lançá -los. Cada processo infantil no método function () tenta agarrar a fechadura. A fechadura só pode ser obtida por um processo de cada vez. Quando isso acontece, eles enviam uma mensagem, incluindo sua identidade e quanto tempo planejam dormir, bem como o índice está fora de ordem, porque é exibido na saída assim que a operação for concluída.

Conclusão

Aprendemos sobre o bloqueio de multiprocessamento do Python neste artigo. O bloqueio é um conceito fundamental no multiprocessamento e na teoria do sistema operacional. Na primeira seção do exemplo, criamos dois processos usando um bloqueio e os chamamos usando um bloqueio para executar a função que definimos. Na seção a seguir do Código, usamos o loop for e definimos o intervalo para "15" para executar o processo. O processo é encerrado quando concluir suas iterações “15”. Na segunda seção, também utilizamos a técnica "Sleep ()" para adiar a execução por um curto período.