Python下的多进程处理

########多进程########

## 创建多进程

# 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号；

## 通过实例化Process对象来创建多进程

# 多进程的意义是: 充分利用CPU， 将任务提交给多个CPU去执行,处理计算密集型任务

import multiprocessing

import time


def job():
    print("当前子进程的名称是%s" % (multiprocessing.current_process()))
# 创建两个进程对象
p1 = multiprocessing.Process(target=job, name="Job1")
p1.start()
time.sleep(1)
p2 = multiprocessing.Process(target=job, name="Job1")
p2.start()
time.sleep(1)
p1.join()
p2.join()
print("任务执行结束")

## 通过继承的方式来创建子进程

import multiprocessing

from multiprocessing import Queue


class JobProcess(multiprocessing.Process):
    def __init__(self, queue, name):
        super(JobProcess, self).__init__()
        self.queue = queue
        self.name = name

    # 重写run方法， 将执行的任务放在里面即可
    def run(self):
        print("当前子进程的名称为%s" % (multiprocessing.current_process()))


queue = Queue(maxsize=5)
processes = []
for i in range(10):
    p = JobProcess(queue, name="Process %s" % (i+1))
    processes.append(p)
    p.start()
[process.join() for process in processes]
print("任务执行结束")

## 多进程案例

注：

    # 1). 开启的进程数有瓶颈， 取决于CPU的个数;
    # 2). 如果处理的数据比较小， 不建议使用多进程， 因为进程的创建和销毁需要时间，
             开启的进程数越多，不一定效率越高;
    # 3). 如果处理的数据量足够大， 0<开启的进程数<cpu个数, 开启的进程数越多， 效率越高;

import multiprocessing

from 多进程与多线程._timeit import mytime


class Jobprocess(multiprocessing.Process):
    def __init__(self, li):
        super(Jobprocess, self).__init__()
        self.li = li

    def run(self):
        list = []
        for item in self.li:
            d = sum(item)
            list.append(d)
        print(list)

@mytime
def use_Proceses():
    lists = [[1, 2, 3, 4, 5], [2, 3, 4, 5, 6],
             [2, 3, 4, 5, 6, 7, 8], [2, 3, 4, 5, 6]] * 1000
    # 对于处理的数据进行分片， 每个进程处理一部分任务;
    proceses = []
    for i in range(0, len(lists), 1000):
        p = Jobprocess(lists[i:i + 1000])
        proceses.append(p)
        p.start()
    [process.join() for process in proceses]
    print("多进程执行结束")


if __name__ == "__main__":
    use_Proceses()

## 守护进程

# 守护进程:
      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 = True
    p1.start()


    # join等待所有子进程执行结束， 再执行主进程
    p1.join(1)
    # 主进程执行
    print("程序执行结束")

## 终止进程

# terminate()
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')

## 进程池

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

import multiprocessing
import time
import threading


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")

## 进程池之ProcessPoolExecutor

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

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

## 分布式进程

                 待续..........

##################################