No processo filho recém-criado, o pai de toda a informação irá copiar os dados entre eles independentemente um do outro.
Use os.fork () para criar
A única maneira para o sistema operacional Unix / Linux, não pode ser usado em janelas.
import os
# 注意，fork函数，只在Unix/Linux/Mac上运行，windows不可以
pid = os.fork()
# 子进程永远返回0，而父进程返回子进程的ID。
if pid == 0:
print('子进程')
else:
print('父进程')
Classes criada usando Processo
multiprocessamento módulo fornece uma classe de processos para representar um processo objecto, o exemplo que se segue demonstra a começar um processo filho e aguarda a sua extremidade:
from multiprocessing import Process
import time
def test(name, age):
for i in range(5):
print("--test--%s\t%d" % (name, age))
time.sleep(1)
print("子进程结束")
if __name__ == '__main__':
p = Process(target=test, args=("aaa", 18))
p.start()
# 等待进程实例执⾏结束，或等待多少秒；
p.join() # 等待的最长时间
print("主进程结束")
"""
输出结果：
--test--aaa 18
--test--aaa 18
--test--aaa 18
--test--aaa 18
--test--aaa 18
子进程结束
主进程结束
"""
join () método representa o principal processo aguarda o processo filho para continuar a descer a implementação for concluída, se o join () comentada, o processo principal foi iniciado sem um baixo pausa para continuar depois que a criança, e depois esperar para que a criança completar as extremidades do programa.
A join () Método comentou os resultados:
"""
输出结果：
主进程结束
--test--aaa 18
--test--aaa 18
--test--aaa 18
--test--aaa 18
--test--aaa 18
子进程结束
"""
Subclasse criada usando o Process
Criar um novo processo também pode ser usado como a moda, você pode personalizar uma classe que herda a classe de processo, cada instância desta classe, é equivalente a um exemplo de um objeto de processo, consulte os seguintes exemplos:
from multiprocessing import Process
import time
import os
class MyProcess(Process):
def __init__(self):
# 如果子类要重写__init__是必须要先调用父类的__init__否则会报错
# Process.__init__(self)
super(MyProcess,self).__init__()
# 重写Porcess的run()方法
def run(self):
print("子进程(%s)开始执行，父进程(%s)" % (os.getpid(), os.getppid()))
for i in range(5):
print("--1--")
time.sleep(1)
if __name__ == '__main__':
t_start = time.time()
p = MyProcess()
p.start()
# p.join()
print("main")
for i in range(5):
print("--main--")
time.sleep(1)
Criar um processo de utilizar a piscina piscina
Quando um pequeno número de processos filhos precisam ser criados, você pode usar diretamente multiprocessamento no Processo nascido em uma múltiplas dinâmica processos, mas se for centenas ou mesmo milhares de alvos, enorme esforço manual para criar um processo, então você pode usar a piscina do módulo de método de multiprocessamento.
Quando a inicialização Pool, você pode especificar um número máximo de processos, quando um novo pedido for apresentado à piscina, se a piscina ainda não está completo, ele irá criar um novo processo para executar o pedido, mas se o número de processos que a piscina tem sido máximo especificado, o pedido vai esperar até o final do processo, há a piscina, vai criar um novo processo para executar, veja exemplo abaixo:
from multiprocessing import Pool
import os
import time
def worker(num):
# for i in range(3):
print("----pid=%d num=%d---" % (os.getpid(), num))
time.sleep(1)
if __name__ == '__main__':
# 定义一个进程池，最大进程数3
pool = Pool(3)
for i in range(10):
print("---%d--" % i)
# 使用非阻塞方式调用func（并行执行)，一般用这个。
# apply堵塞方式必须等待上一个进程退出才能执行下一个进程,用的不多。
pool.apply_async(worker, (i,))
# 关闭进程池
pool.close()
# 等待所有子进程结束，主进程一般用来等待
pool.join() # 进程池后面无操作时必须有这句
