Fila multiprocessante em Python

O elemento mais crucial da estrutura de dados é a fila. A fila de estrutura de dados “Primeiro em, First Out”, que é a base para o multiprocessamento do Python é comparável. São fornecidas filas à função do processo para permitir que o processo colete os dados. O primeiro item de dados a serem eliminados da fila é o primeiro item a ser inserido. Utilizamos o método "put ()" da fila para adicionar os dados à fila e seu método "get ()" para recuperar os dados da fila.

Exemplo 1: Usando o método Queue () para criar uma fila multiprocessante no Python

Neste exemplo, criamos uma fila multiprocessante em Python usando o método "fila ()". Multiprocessamento refere -se ao uso de uma ou mais CPUs em um sistema para executar dois ou mais processos simultaneamente. O multiprocessamento, um módulo construído em Python, facilita a alternância entre os processos. Devemos estar familiarizados com a propriedade do processo antes de trabalhar com multiprocessamento. Estamos cientes de que a fila é um componente crucial do modelo de dados. A fila de dados padrão, que é construída com base na idéia "primeiro a primeira saída", e o multiprocessamento do Python são contrapartes exatas. Em geral, a fila armazena o objeto Python e é crucial para a transferência de dados entre as tarefas.

A ferramenta "Spyder" é usada para implementar o script python presente, então vamos simplesmente começar. Primeiro devemos importar o módulo multiprocessamento, porque estamos executando o script multiprocessante do Python. Fizemos isso importando o módulo multiprocessamento como "M". Usando-os.Técnica da fila () ”, invocamos o método multiprocessante“ fila () ”. Aqui, criamos uma variável chamada "fila" e colocamos o método "fila ()" multiprocessante. Como sabemos que a fila armazena itens em um pedido de "primeiro entrada, primeiro a sair", o item que adicionamos primeiro é removido primeiro. Após o lançamento da fila multiprocessante, chamamos o método "print ()", passando a declaração "existe uma fila multiprocessante" como seu argumento para exibi -lo na tela. Então, porque armazenamos a fila construída nesta variável, imprimimos a fila passando a variável "fila" na parêntese do método "print ()".

A imagem a seguir mostra que a fila multiprocessante em Python agora é construída. A declaração de impressão é mostrada primeiro. Depois que esta fila de multiprocessamento é construída no endereço de memória designado, ela pode ser usada para transferir os dados distintos entre dois ou mais processos em execução.

Exemplo 2: Utilizando o método "QSIZE ()" para determinar o tamanho da fila multiprocessante no Python

Determinamos o tamanho da fila multiprocessante neste caso. Para calcular o tamanho da fila multiprocessante, usamos o método "QSize ()". A função "QSIZE ()" retorna o tamanho real da fila multiprocessante em Python. Em outras palavras, esse método fornece o número total de itens em uma fila.

Vamos começar importando o módulo multiprocessamento do Python como "M" antes de executar o código. Então, usando o “M.Comando da fila () ”, invocamos a função multiprocessante“ fila () ”e colocamos o resultado na variável“ fila ”. Em seguida, usando o método "put ()", adicionamos os itens à fila na seguinte linha. Este método é usado para adicionar os dados a uma fila. Portanto, chamamos de "fila" com o método "put ()" e fornecemos os números inteiros como seu elemento em seus parênteses. Os números que adicionamos são "1", "2", "3", "4", "5", "6" e "7" usando as funções "put ()".

Além disso, usando "fila" para obter o tamanho da fila multiprocessante, chamamos o "QSIZE ()" com a fila multiprocessante. Então, na variável "resultado" recém -formada, salvamos o resultado do método "QSize ()". Depois disso, chamamos o método "print ()" e passamos a declaração "o tamanho da fila multiprocessante é" como seu parâmetro. Em seguida, chamamos a variável "resultado" na função "print ()", pois o tamanho é salvo nesta variável.

A imagem de saída tem o tamanho exibido. À medida que usamos a função "put ()" para adicionar sete elementos à fila multiprocessante e à função "QSize ()" para determinar o tamanho, o tamanho da fila multiprocessante "7" é exibido. A declaração de entrada "o tamanho da fila multiprocessante" é mostrada antes do tamanho.

Exemplo 3: Usando o método "put ()" e "get ()" na fila de multiprocessamento do Python

Os métodos da fila “put ()” e “get ()” da fila multiprocessamento de Python são usados ​​neste exemplo. Desenvolvemos duas funções definidas pelo usuário neste exemplo. Neste exemplo, definimos uma função para criar um processo que produz “5” inteiros aleatórios. Também usamos o método "put ()" para adicioná -los a uma fila. O método "put ()" é usado para colocar os itens na fila. Então, para recuperar os números da fila e retornar seus valores, escrevemos outra função e a chamamos durante o procedimento. Usamos a função "get ()" para recuperar os números da fila, pois esse método é usado para recuperar os dados da fila que inserimos usando o método "put ()".

Vamos começar a implementar o código agora. Primeiro, importamos as quatro bibliotecas que compõem este script. Primeiro, importamos o “sono” do módulo de tempo para adiar a execução por algum tempo medido em segundos, seguido de “aleatório” do módulo aleatório que é usado para gerar números aleatórios, depois o “processo” do multiprocessamento porque este código cria um processo e, finalmente, a "fila" do multiprocessamento. Ao construir inicialmente uma instância de classe, a fila pode ser usada. Por padrão, isso estabelece uma fila infinita ou uma fila sem tamanho máximo. Ao definir a opção de tamanho máximo para um número maior que zero, é possível fazer uma criação com uma restrição de tamanho.

Nós definimos uma função. Então, como essa função é definida pelo usuário, damos o nome "function1" e passamos o termo "fila" como seu argumento. Depois disso, invocamos a função "print ()", passando o "construtor: correndo", "Flush" e o objeto "verdadeiro" instruções . A função de impressão do Python tem uma opção exclusiva chamada Flush que permite que o usuário escolha se deve ou não buffer esta saída. O próximo passo é gerar a tarefa. Para fazer isso, usamos "para" e criamos a variável "M" e definimos o intervalo para "5". Então, na próxima linha, use “aleatória ()” e armazene o resultado na variável que criamos, que é “valor.”Isso indica que a função agora termina suas cinco iterações, com cada iteração criando um número inteiro aleatório de 0 a 5.

Então, na etapa seguinte, chamamos a função "Sleep ()" e passamos o argumento "valor" para adiar a parte por um certo número de segundos. Em seguida, chamamos a "fila" com o método "put ()" para adicionar essencialmente o valor à fila. O usuário é então informado de que não há mais trabalho a ser feito invocando a “fila.Método put () ”mais uma vez e passando o valor“ nenhum ”. Em seguida, executamos o método "Print ()", passamos a declaração "Builder: Ready" junto com "Flush" e o definimos como "True".

Agora definimos uma segunda função, "function2" e atribuímos a palavra -chave "fila" como seu argumento a ela. Em seguida, chamamos a função "print ()" ao passar o relatório afirma "Usuário: Executar" e "Flush", que está definido como "True". Iniciamos a operação de "function2" usando a condição While True para tirar os dados da fila e colocá -los na variável "item" recém -criada. Então, usamos a condição "se", "item não é", para interromper o loop se a condição for verdadeira. Se nenhum item estiver disponível, ele interrompe e pede ao usuário um. A tarefa interrompe o loop e termina neste caso se o item obtido do valor for nulo. Então, na etapa seguinte, chamamos a função "print ()" e fornecemos o relatório "Usuário: Pronto" e "Flush = True" Parâmetros.

Em seguida, entramos no processo principal usando o "if-name = main_". Criamos uma fila chamando o método "fila ()" e armazenando -o na variável "fila". Em seguida, criamos um processo chamando a função do usuário de "função2". Para isso, chamamos a classe de "processo". Dentro dele, passamos o "Target = function2" para chamar a função no processo, passar o argumento "fila" e armazená -lo na variável "user_process". O processo começa chamando o método "start ()" com a variável "user_ process". Em seguida, repetimos o mesmo procedimento para chamar a "função1" no processo e colocá -lo na variável "Processo do construtor". Em seguida, chamamos os processos com o método "junção ()" para aguardar a execução.

Agora que é apresentado, você pode ver as declarações de ambas as funções na saída. Ele exibe os itens que adicionamos usando os métodos "put ()" e "get ()" usando os métodos "get ()", respectivamente.

Conclusão

Aprendemos sobre a fila de multiprocessamento do Python neste artigo. Utilizamos as ilustrações dadas. No começo, descrevemos como criar uma fila no multiprocessamento de Python usando a função da fila (). Em seguida, usamos o método "QSize ()" para determinar a fila . Também usamos os métodos de put () e get () da fila. A classe do sono do módulo do tempo e a classe aleatória do módulo aleatório foram discutidos no último exemplo.