进程

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