Python中的进程创建

Python中的进程创建

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

---

一.Linux创建子进程

1. Linux创建子进程的原理:

- 父进程和子进程, 如果父进程结束， 子进程也随之结束;
- 先有父进程， 再有子进程， 通过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  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(100)

二.创建多进程

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(3)
    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())

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

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

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.multiprocessing.pool方法

import  multiprocessing
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, 1)
# 获取进程是否执行结束；
f1.done()
# 获取子进程执行的结果
f1.result()

# 第2种方式:
pool = ProcessPoolExecutor(max_workers=4)
for res in pool.map(job, range(1,100)):
    print(res)