python子进程修改矩阵 python创建子进程

对于操作系统来说,一个任务就是一个进程(Process),比如打开一个浏览器就是启动一个浏览器进程,打开一个记事本就启动了一个记事本进程,打开两个记事本就启动了两个记事本进程,打开一个 Word 就启动了一个 Word 进程。

一 Linux创建子进程

1.原理:

父进程和子进程, 如果父进程结束，子进程也随之结束;
先有父进程，再有子进程，通过fork函数实现;

2. fork函数的返回值:调用该方法一次， 返回两次;

产生的子进程返回一个0
父进程返回子进程的pid;

3. Window也能使用fork函数么?

Windows没有fork函数， Mac有fork函数(Unix -> Linux, Unix-> Mac),封装了一个模块multiprocessing

4. 常用方法:

os.fork()
os.getpid(): 获取当前进程的pid;
os.getppid(): parent process id, 获取当前进程的父进程的id号；

import multiprocessing
import os
import time
print('当前进程(pid=%d)正在运行...' %(os.getpid()))
print('当前进程的父进程(pid=%d)正在运行...' %(os.getppid()))
print('正在创建子进程...')
pid=os.fork()
pid2=os.fork()
print('第1个:',pid)
print('第2个:',pid2)
if pid==0:
   print('这是创建的子进程，子进程的id为%s，父进程的id为%s' %(os.getpid(),os.getppid()))
else:
   print('当前是父进程[%s]的返回值%s' %(os.getpid(),pid))
time.sleep(3)

二 创建多进程

1.通过实例化对象创建

import multiprocessing
import threading
def job():
    print('当前子进程的名称为%s' %(multiprocessing.current_process()))
#创建一个进程对象
p1=multiprocessing.Process(target=job)
#运行进程，执行任务
p1.start()

#创建一个进程对象
p2=multiprocessing.Process(target=job)
#运行进程，执行任务
p2.start()

#等待所有的子进程执行结束，再执行主进程的内容
p1.join()
p2.join()
print('任务执行结束...')

2.通过继承的方式创建

import multiprocessing
class JobProcess(multiprocessing.Process):
    #重写Process的构造方法，获取新的属性
    def __init__(self,queue):
        super(JobProcess, self).__init__()
        self.queue=queue
    #重写run方法，将执行的任务放在里面即可
    def run(self):
        print('当前子进程名称为%s' %(multiprocessing.current_process()))

processes=[]
#启动10个子进程，来处理需要执行的任务
for i in range(10):
    #实例化对象
    p=JobProcess(queue=3)
    processes.append(p)
    #启动多进程，处理需要执行的任务
    p.start()

#等待所有的子进程执行结束，再继续执行主进程
[process.join() for process in processes]
#执行主进程
print('任务执行结束...')

三 守护进程

守护线程:
setDeamon:
True: 主线程执行结束， 子线程不再继续执行;
Flase:主线程执行结束， 子线程继续执行;
守护进程:
setDeamon:
True: 主进程执行结束， 子进程不再继续执行;
Flase:主进程执行结束， 子进程继续执行;

import multiprocessing
import time
def job():
    name=multiprocessing.current_process()
    print('开始运行')
    time.sleep(2)
    print('结束进程')
if __name__=='__main__':
    #启动一个子进程
    p1=multiprocessing.Process(target=job,name='use deamon')
    #True/False守护线程:
    p1.daemon=False
    p1.start()
    #join等待所有的子进程执行结束，再执行主进程
    p1.join(1)
    #主进程执行
    print('程序执行结束')

守护进程和守护线程是一样的，都是为了保证在主进程（主线程）完成时，强行结束未完成的子进程（子线程）

四 终止进程

import time
import  multiprocessing

def job():
    print("start.....")
    time.sleep(1)
    print('end.......')
if __name__ == '__main__':
    p = multiprocessing.Process(target=job)
    print("Before:", p.is_alive())
    p.start()       #启动子进程
    print("During:", p.is_alive())
    p.terminate()   #终止子进程
    print('terminate:', p.is_alive())
    p.join()        #等待子进程彻底终止
    print("joined:", p.is_alive())

终止进程 terminate通常和 join一起使用的，当 terminate终止进程时，是会有一个销毁的过程，进程并没有完全结束，这里就需要 join来等待所有的子进程结束后，再去执行主进程

五 进程间的通信(生产者消费者模型)

通过队列来实现进程间的通信

import  multiprocessing
from multiprocessing import Queue
import time

class Producer(multiprocessing.Process):
   # 往队列里面写内容
   def __init__(self, queue):
       super(Producer, self).__init__()
       self.queue = queue

   def run(self):
       for i in range(10):
           self.queue.put(i)
           time.sleep(0.1)
           print("传递消息,内容为:%s" %(i))

class Consumer(multiprocessing.Process):
   # 读取队列里面的内容
   def __init__(self, queue):
       super(Consumer, self).__init__()
       self.queue = queue

   def run(self):
       # 判断队列是否为空,如果是,跳出循环,不会再去从队列获取数据;
       # while not self.queue.empty():
       while True:
           time.sleep(0.1)
           print("读取进程传递的消息:%s" %(self.queue.get()))

if __name__ == "__main__":
   q = Queue()
   p1 = Producer(q)
   c1 = Consumer(q)

   p1.start()
   c1.start()

   p1.join()
   c1.terminate()
   c1.join()
   print('All done')

六 分布式进程

1.为什么要分布式进程?

任务需要处理的数据特别大, 希望多台主机共同处理任务;

2. 如何实现分布式进程?

multiprocessing.managers子模块里面可以实现将进程分布到多台机器上;
Master: 管理端， 分配任务给其他主机;
Worker1: 被管理端， 处理master给予的任务;
Worker2:被管理端， 处理master给予的任务;

3. 特别重要的类:

BaseManager： 提供了不同机器进程之间共享数据的一种方法;

from  multiprocessing.managers import  BaseManager

七 进程池

如果启动大量子进程， 会消耗时间用来创建和销毁子进程,使用进程池， 不需要启动大量的进程;

1.multiprocessing.pool方法

import  multiprocessing
import time
def job(id):
    print('start %d.....' %(id))
    print('end %d.....' %(id))
# 创建一个进程池对象
pool = multiprocessing.Pool(10)
# 给进程池的进程分配任务
for i in range(10):
    pool.apply_async(job,args=(i, ) )
pool.close()
# 等待所有的子进程执行结束
pool.join()
print('success')

2.ProcessPoolExecutor方法

from concurrent.futures import  ProcessPoolExecutor
def job(id):
    print('start %d.....' %(id))
    print('end %d.....' %(id))
    return  id
#第1种方式: submit
pool = ProcessPoolExecutor(max_workers=4) # 分配任务给子进程， 并且返回一个Future对象;
f1 = pool.submit(job, 10)
#获取进程是否执行结束；
f1.done()
#获取子进程执行的结果
f1.result()