Рубрики
Без рубрики

Uma Pequena Intervinução программа, паралела, мультипроцессаменто com python

Hoje Acho que é hora de go empocar a tratar de um tema que é é muito discutido mas eu che que os iniciant … Tagged с Python.

Hoje Acho que é hora de go empocar a tratar de um tema que é é muito discutido mas eacho que oniciantes temificuldade pra visualizar na cabeça. Concorrência e Paralelilismo.

Hoje em dia todo mundo tem um computador potente. Encontrar Processadores Com 4, 6 OUTE 8 Núcleos. Mesmo o mais fraco Intel i3 é Dual Core Com 3 ГГц oute mesmo seu cellular android, com o Chipset Snapdragon 632 Qualcomm Sdm632, é nada menos que octa core com 1,8 ГГц када. Então, do seu celular, настольный компьютер, сервидоры, estamos claramente num mundo massivamente paralelo.

Nat entanto, o intérprete python parrão foi projetado e sosui um mecanismo seguro para threads, o Chamado “gil” (глобальная блокировка интерпретатора). Para evitar conflitos entre как нити, Ele Execure Apenas Uma instrução de Cada Vez (O Chamado Processamento Serial OU однопоточное). Nesta Intervução Irei Falar de forma breve alguns canceitos важно Concorrência E Paralelismo , Контекст, потоки E Processos E emedçar a falar sobre o modulo python multiprocessing e ao contrario do que possa parecer, na Realidade o básico nionao é tãao syquestado assim.

É comum achar que concorrência e paralelilismo são a mesma coisa, mas não. Роб Пайк, мм -dos criadores da linguagem go, em em uma apresentação:

Concorrência é sobre Лидар com várias coisas ao mesmo tepo e paralelilismo é sobre Fazer Várias Coisas Ao Mesmo Tempo.

Mas Vamos a Uma definição mais formal:

Concorrência : «É a abacidade de se исполнитель Duas ou mais tarefas em um mesmo período de tempo» Paralelismo : ” Paralelismo é Sobre A Execução Paralela de Tarefas, Ou Seja, Mais de Uma por Vez de forma Simultânea “

Contexto é usado quando uma tarefa poder ser Interrompida e em algum ormom Porém, существует um custo alto into Quanto menor o contexto menor é aTência.

Em Sistemas Operacionais Tradicionais, Cado Processo Tem Um Espaço de EndereCamento e Um único Thread (Fluxo) de Controle. Как нити, Sã utilizadas para que múltiplas execuções ocorram no mesmo ambiente do processo com grande grau de independencia uma da autra. Como Cada Thread Pode Ter Acesso A Qualquer endereCo de Memória Dentro do Espaço de endereCamento do Processo, Uma Thread Pode Ler, Escrever outé mesmo apagar overse a pilha de autra thread.

Aqui, Veremos O Módulo Многоподобная Do Python e Como Podemos usá-lo para enviar vários processos que podem ser executos Independentememente Um Do autro, Fim de Fazer O Melhor USO DOS NOSSOS Núcleos de CPU.

O módulo de multiprocessamento na biblioteca padrão do python vesui muitos recursos poderosos. SE Você Quiser Ler Sobre Todos Os Detalse E Ir Mais Ado Recomendo o uso da Documentação Oficial Como Ponto de Entrada.

Nas Seção A Seguir, Desejo Fornecer Uma Breve Visão Geral Para Mostrar Como O Módulo de Multiprocessing Poderá Ser Usado Para PrageAção Paralela.

Многообразование Oferece vários recursos hoje eu irei founcar na classe pourt que é mais commoniente para tarefas simples de processamento paralelo.

ESsectEm Quatro métodos Que Sheantemente Interessantes:

  • Pool.apply
  • Pool.map
  • Pool.apply_async
  • Pool.map_async

OS Métodos Pool.apply E Pool.map Сан -базовые эквиваленты às funcões применяют e map nativas do python. Antes de chegarmos às variants async dos métodos pool, vamos dar uma olhada em um exemplo simples usando pool.apply e pool.map. Aqui DefiniRemos o número de Processos Como 4, o Que que que abe pool pool ormitirá apenas 4 processos emecução ao mesmo tempo.

from random import randint
from time import sleep, time
from multiprocessing.pool import ThreadPool

def print_names(name):
    sleep(randint(1, 3))
    print('Meu nome é: {}'.format(name))

runtime = []
threads = []
names = ['Adson', 'Gabriel', 'Siqueira', 'Ronaldo', 'Gleilson',
         'Emerson', 'Joselito', 'Piloto', 'Kleber', 'Mauricio']

pool = ThreadPool(processes=4)
start = time()

for name in names:
    async_result = pool.apply(print_names, (name,))
    threads.append(async_result)

end = time()
print('tempo de execução da tradução: {}'.format(end - start))

Tempo de execução da tradução : 21.03 Сегунды

from random import randint
from time import sleep, time
from multiprocessing.pool import ThreadPool


def print_names(name):
    sleep(randint(1, 3))
    print('Meu nome é: {}'.format(name))


runtime = []
threads = []
names = ['Adson', 'Gabriel', 'Siqueira', 'Ronaldo', 'Gleilson',
         'Emerson', 'Joselito', 'Piloto', 'Kleber', 'Mauricio']

pool = ThreadPool(processes=4)
start = time()

for name in names:
    async_result = pool.map(print_names, (name,))
    threads.append(async_result)

end = time()
print('tempo de execução da tradução: {}'.format(end - start))

Tempo de execução da tradução : 24.03 Сегунды

O pool.map e pool.apply bloqueará o Programa Принципал Até Que todos ososos sejam concluídos, o que é bastante útil se Queremos Obteraados Ordenados.

POR OUTRO LADO, как варианты Async Enviarão Todos Os Processos de Uma Só Vez e recuperarão os resultados assim que terminarem. Outra diferença que é bastante Que é que precisamos usar o método get () após a amada de apply_async () para obter os valores dos processos

from random import randint
from time import sleep, time
from multiprocessing.pool import ThreadPool


def print_names(name):
    sleep(randint(1, 3))
    print('Meu nome é: {}'.format(name))


runtime = []
threads = []
names = ['Adson', 'Gabriel', 'Siqueira', 'Ronaldo', 'Gleilson',
         'Emerson', 'Joselito', 'Piloto', 'Kleber', 'Mauricio']

pool = ThreadPool(processes=4)
start = time()

for name in names:
    async_result = pool.map_async(print_names, (name,))
    threads.append(async_result)

letters_list = [result.get() for result in threads]

end = time()
print('tempo de execução da tradução: {}'.format(end - start))

Tempo de execução da tradução : 6.00 сегунды

from random import randint
from time import sleep, time
from multiprocessing.pool import ThreadPool


def print_names(name):
    sleep(randint(1, 3))
    print('Meu nome é: {}'.format(name))


runtime = []
threads = []
names = ['Adson', 'Gabriel', 'Siqueira', 'Ronaldo', 'Gleilson',
         'Emerson', 'Joselito', 'Piloto', 'Kleber', 'Mauricio']

pool = ThreadPool(processes=4)
start = time()

for name in names:
    async_result = pool.apply_async(print_names, (name,))
    threads.append(async_result)

letters_list = [result.get() for result in threads]

end = time()
print('tempo de execução da tradução: {}'.format(end - start))

Tempo de execução da tradução : 6.01 Сегунды

Отчеты Concorrência e Paralelilismo Só Falando é Muito Difícil. Vocês ainda voao precisar praticar program и centenas de vezes coisas diferentes pra emedçar antender de verdade como в качестве Coisas funcionam. Eu Espero Que a Explicaço que eu dei agora pelo menos amude um pouco ocês terem umaemem na cabeça do que esperar quando colocarem как mãos na massa.

SE Tiverem Dúvidas Não Deixem de Mandar Nos Comentários Abaixo. Валеу!

Оригинал: “https://dev.to/adsonrodrigues/uma-pequena-introducao-a-programacao-paralela-e-multiprocessamento-com-python-192a”