python大佬养成计划-----多进程

进程

Python是运行在解释器中的语言，查找资料知道，python中有一个全局锁（GIL），在使用多进程(Thread)的状况下，不能发挥多核的优点。而使用多进程(Multiprocess)，则能够发挥多核的优点真正地提升效率。
若是多线程的进程是CPU密集型的，那多线程并不能有多少效率上的提高，相反还可能会由于线程的频繁切换，致使效率降低，推荐使用多进程；若是是IO密集型，多线程的进程能够利用IO阻塞等待时的空闲时间执行其余线程，提高效率。

建立进程

linux和mac系统特殊方法

1.Linux建立子进程的原理:
1). 父进程和子进程, 若是父进程结束， 子进程也随之结束;
2). 先有父进程， 再有子进程， 经过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)

win系统

在win系统下，使用实例化multiprocessing.Process建立进程须添加'if __name__=="__main__"'，不然会出现如下报错：

RuntimeError:

An attempt has been made to start a new process before the
current process has finished its bootstrapping phase.

This probably means that you are not using fork to start your
child processes and you have forgotten to use the proper idiom
in the main module:

   if __name__ == '__main__':
       freeze_support()
       ...

The "freeze_support()" line can be omitted if the program
is not going to be frozen to produce an executable.

import  multiprocessing
def job():
    print("当前子进程的名称为%s" %(multiprocessing.current_process()))
if __name__=="__main__":    #win操做系统须要加上,不然会出现异常报错RuntimeError

    # 建立一个进程对象(group=None, target=None, name=None, args=(), kwargs={})
    p1 = multiprocessing.Process(target=job)
    p2 = multiprocessing.Process(target=job)
    # 运行多进程， 执行任务
    p1.start()
    p2.start()

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

经过重写multiprocessing.Process类建立多进程

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

if __name__=="__main__":
    processes = []
    # 启动10个子进程， 来处理须要执行的任务;
    for i in range(10):
        #示例化类，建立进程
        p = JobProcess(queue=3)
        processes.append(p)
        #启动多进程，执行任务
        p.start()
    #等待全部的子进程结束，再执行主进程
    [pro.join() for pro in processes]
    print("任务执行结束")

守护进程

守护线程:

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

守护进程:

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

import multiprocessing
import time
def deamon():
    #守护进程：当主程序运行结束，子进程也结束
    name = multiprocessing.current_process()
    print("%s开始执行" %(name))
    time.sleep(3)
    print("执行结束")

if __name__=="__main__":
    p1 = multiprocessing.Process(target=deamon,name='hello')
    p1.daemon = True
    p1.start()
    time.sleep(2)
    print("整个程序执行结束")

终止进程

有些进程或许再执行死循环任务，此时咱们手动结束进程
terminate()

import multiprocessing
import time

def job():
    name = multiprocessing.current_process()
    print("%s进程开启" %(name))
    time.sleep(3)
    print("进程结束")

if __name__=="__main__":
    p = multiprocessing.Process(target=job)
    print("进程开启：",p.is_alive())
    p.start()
    print("进程开启：",p.is_alive())
    p.terminate()
    print("进程开启：",p.is_alive())
    time.sleep(0.001)
    print("进程开启：",p.is_alive())
    print("程序执行结束")

计算密集型和I/O密集型

计算密集型任务的特色是要进行大量的计算， 消耗CPU资源， 好比计算圆周率、 对视频进行高清解码等等， 全靠CPU的运算能力。 这种计算密集型任务虽然也能够用多任务完成， 可是任务越多， 花在任务切换的时间就越多， CPU执行任务的效率就越低， 因此， 要最高效地利用CPU， 计算密集型任务同时进行的数量应当等于CPU的核心数。计算密集型任务因为主要消耗CPU资源， 所以， 代码运行效率相当重要。 Python这样的脚本语言运行效率很低， 彻底不适合计算密集型任务。 对于计算密集型任务，最好用C语言编写。

第二种任务的类型是IO密集型， 涉及到网络、 磁盘IO的任务都是IO密集型任务， 这类任务的特色是CPU消耗不多， 任务的大部分时间都在等待IO操做完成（由于IO的速度远远低于CPU和内存的速度）。对于IO密集型任务， 任务越多， CPU效率越高， 但也有一个限度。 常见的大部分任务都是IO密集型任务， 好比Web应用。

多进程和多线程对比

多进程模式最大的优势就是稳定性高， 由于一个子进程崩溃了， 不会影响主进程和其余子进程。（固然主进程挂了全部进程就全挂了， 可是Master进程只负责分配任务， 挂掉的几率低）著名的Apache最先就是采用多进程模式。

多进程模式的缺点是建立进程的代价大， 在Unix/Linux系统下， 用 fork 调用还行， 在Windows下建立进程开销巨大。 另外， 操做系统能同时运行的进程数也是有限的， 在内存和。CPU的限制下， 若是有几千个进程同时运行， 操做系统连调度都会成问题。

多线程模式一般比多进程快一点， 可是也快不到哪去， 并且， 多线程模式致命的缺点就是任何一个线程挂掉均可能直接形成整个进程崩溃， 由于全部线程共享进程的内存。 在Windows上， 若是一个线程执行的代码出了问题， 你常常能够看到这样的提示：“该程序执行了非法操做， 即将关闭”， 其实每每是某个线程出了问题， 可是操做系统会强制结束整个进程。
这里经过一个计算密集型任务，来测试多进程和多线程的执行效率。

import multiprocessing
import threading
from mytimeit import timeit

class JobProcess(multiprocessing.Process):
    def __init__(self,li):
        super(JobProcess, self).__init__()
        self.li = li
    def run(self):
        for i in self.li:
            sum(i)


class JobThread(threading.Thread):
    def __init__(self,li):
        super(JobThread, self).__init__()
        self.li = li
    def run(self):
        for i in self.li:
            sum(i)
@timeit
def many_processs():
    li = [[24892,23892348,239293,233],[2382394,49230,2321234],[48294,28420,29489]]*10
    processes = []
    for i in li :
        p = JobProcess(li)
        processes.append(p)
        p.start()
    [pro.join() for pro in processes]
    print("多进程执行任务结束，✌")
@timeit
def many_thread():
    #建立进程和销毁进程是时间的，若是li长度不够，会形成多线程快过多进程
    li = [[24892,23892348,239293,233],[2382394,49230,2321234],[48294,28420,29489]]*1000
    threads = []
    for i in li :
        t = JobThread(li)
        threads.append(t)
        t.start()
    [thread.join() for thread in threads]
    print("多线程执行任务结束，✌")
if __name__ =="__main__":
    many_processs()
    many_thread()

进程间通讯-生产者消费者模型与队列

演示了生产者和消费者的场景。生产者生产货物，而后把货物放到一个队列之类的数据结构中，生产货物所要花费的时间没法预先肯定。消费者消耗生产者生产的货物的时间也是不肯定的。
经过队列来实现进程间的通讯

import multiprocessing
import threading
from multiprocessing import Queue

class Producer(multiprocessing.Process):
    def __init__(self,queue):
        super(Producer, self).__init__()
        self.queue = queue
    def run(self):
        for i in range(13):
            #往队列添加内容
            self.queue.put(i)
            print("生产者传递的消息为%s" %(i))
        return self.queue

class Consumer(multiprocessing.Process):
    def __init__(self,queue):
        super(Consumer, self).__init__()
        self.queue = queue
    def run(self):
        #获取队列内容
        #get会自动判断队列是否为空,若是是空， 跳出循环， 不会再去从队列获取数据;
        while True:
            print("进程获取消息为：%s" %(self.queue.get()))
if __name__=="__main__":
    queue  = Queue(maxsize=100)
    p = Producer(queue)
    p.start()
    c = Consumer(queue)
    c.start()
    p.join()
    c.join(2)
    c.terminate()   #终止进程
    print("进程间通讯结束，( •̀ ω •́ )y")