进程.

操作系统的背景知识:
    操作系统的作用:
        1.封装了丑陋复杂的接口,提供了良好的抽象接口
        2.管理.调度程序,并将多个进程或者程序对硬件资源的竞态请求变的有序化
        多道技术:
            产生背景:针对于单核,实现并发
            空间上的复用:内存中存在多道程序
            时间上的复用:
                1.遇到io口就切换
                2.一个进程长时间被CPU处理的时,操作系统会强硬的将cpu调出去处理下一个进程

进程:是计算机中关于数据集合上的一次运行活动,是系统资源分配和调度的基本单位
    是操作系统结构的基础
    也是正在运行程序的实例

进程的调度: 先来先服务调度算法,
            短作业优先调度算法,
            时间片轮转法,
            多级反馈队列

进程的并行并发:
    并行:指的是两个或者多个cpu同时分别执行两个或者多个进程
    并发:指的一个cpu对多个进程轮流交替使用
    区别:虽然给人的感觉是同时执行的,但是并发是在多个进程之间交替执行

进程的同步异步:
        同步:一个任务的完成需要依赖另一个任务的完成
        异步:任务的完成不需要被等待的任务完成

进程的三态状态:就绪,阻塞,运行

进程的创建和结束:
    创建:UNIX中调用的是fork
        Windows是CreateProcess
        创建子进程:UNIX和Windows
            相同点:都会将父进程复制一份,存放到另一个地址空间,也就是子进程,但是两个进程之间在地址空间的操作没有关系
            不同点:NUIX中子进程的地址空间是父进程的一个副本,存在只读的共享内存区的
                    windows的子进程空间跟父进程的进程空间多一些东西

在python程序中的进程操作:
    multiprocess模块:是python中的一个操作,管理进程的包.包中几乎包含了跟进程有关的所有子模块
                    大致分为四类:
                        创建进程部分
                        进程同步部分
                        进程池部分
                        进程之间数据共享

1.创建进程部分(multiprocess.process模块)

　　process模块是一个创建进程的模块,借助这个模块就可以完成进程的创建
　　创建进程的时候windows必须要用if __name__=__main__():

　　在进程中,main之上的代码都是子进程的代码,主进程只有在子进程结束后才算真正意义上结束

import time
from multiprocessing import Process #导入Process模块
def func(name):
    time.sleep(0.1)
    print('hello',name)
    print('我是子进程')
if __name__ == '__main__':
    p = Process(target=func,args=('智障',))
    #由Process实例化出的一个对象,表示一个子进程中的任务(尚未启动)
    p.start()#启动进程
    time.sleep(1)
    print('我是主进程')

　　通过类的方式创建一个进程:

from multiprocessing import Process
class MyProcess(Process):
    def __init__(self,name):
        super().__init__()
        self.name = name
    def run(self):
        print('%s正在吃饭'%self.name)
if __name__ == '__main__':
    p = MyProcess('alex')
    p.start()
    p.join()

　　p.jion()的用法:是主进程等待p进程(子进程)的结束后再结束

import time
from multiprocessing import Process
def func():
    print('子进程开始')
    time.sleep(1)
    print('子进程结束')
if __name__ == '__main__':
    p = Process(target=func)
    p.start()
    p.join()
    print('主进程')
# 结果:
    子进程开始
    子进程结束
    主进程

　　多个进程运行时,join的用法: 多个进程执行的时候,join的个数和进程个数一样且必须连续放置

from multiprocessing import Process
def func(name):
    print('hello',name)
if __name__ == '__main__':
    p_l = []
    for i in range(5):
        p = Process(target=func,args=('智障',))
        p.start()
        p_l.append(p)
    for p in p_l:
        p.join()
    print('主程序')

　　查看进程属性:

查看进程的id:需要调用带os模块 (os.getpid , os.getppid)
import os
from multiprocessing import Process
def func():
    print('子进程',os.getpid())
    # print('主进程',os.getppid())
if __name__ == '__main__':
    print('主进程', os.getpid())
    for i in range(5):
        p = Process(target=func)
        p.start()
在子程序中os.getpid()可以查看子进程id
在主程序中os.getpid()可以查看本进程id

验证进程之间的数据隔离:

进程之间的数据是隔离的,

from multiprocessing import Process
n = 100
def func():
    global n
    n = 2
if __name__ == '__main__':
    p = Process(target=func)
    p.start()
    print(n)

守护进程:会随着主程序的结束而结束
　　1.守护进程会在主进程代码运行结束后就终止

　　2.守护进程内无法再开启子程序,否则抛出异常

# 主进程必须在子进程结束后回收子进程的代码后才算真正的结束
# 必须在p.start()前设置守护进程
# 守护进程若是主进程结束后,就不会再执行

import time
from multiprocessing import Process
def foo():
    print(123)
    time.sleep(1)
    print("end123")
def bar():
    print(456)
    time.sleep(3)
    print("end456")
if __name__ == '__main__':
    p1 = Process(target=foo)
    p2 = Process(target=bar)
    p1.daemon = True
    p1.start()
    p2.start()
    time.sleep(2)
    print('主进程')
# 结果:
123
456
end123
主进程
end456

进程的其他用法:
p.teminate()关闭进程,但是不会立即关闭 ,所以is_live立刻查看的结果还可能是True

2.进程同步(multiprocess.Lock):为了维护数据的安全,牺牲了效率利用互斥锁

from multiprocessing import Process,Lock
import time
import os
def func(name,lock):
    lock.acquire()
    print('%s: %s 正在跑'%(name,os.getpid()))
    time.sleep(1)
    print('%s: %s已经跑完了'%(name,os.getpid()))
    lock.release()
if __name__ == '__main__':
    lock = Lock()
    p1 = Process(target=func,args=('小明',lock))
    p2 = Process(target=func,args=('小红',lock))
    p1.start()
    p2.start()

加锁可以保证多个进程修改同一个数据的时候,只能在同一时间一个程序进行修改,就是串行修改

加锁的方式使代码的效率变低，还要自己进行加锁处理，所以大部分都是采用管道和队列的方式
（基于消息的ipc机制，进程之间的通信）



3.进程间的通信 队列 multiprocess.Queue:

import  time
from multiprocessing import Process,Queue
def func(q):
    q.put([time.asctime(),'form alex','hello'])
if __name__ == '__main__':
    q = Queue()#参数为显示队列的里的元素个数
    p =Process(target=func,args=(q,))
    p.start()
    print(q.get())
    p.join()

JionableQueue()跟Queue的方法一样,但是多了几个
q.task_done()#使用此方法发出信号,表示q.get()返回的项目已经被处理;
如果调用的此方法次数大于从队列中删除的项目数量,将引发ValueError异常
q.join()生产者将使用此方法进行阻塞

# 生产者和消费者模型(欠着)

3.进程之间的数据共享(Manager模块)
　　Manager提供可共享的数据类型但是不加锁操作的共享数据肯定会出错

from multiprocessing import Manager,Process,Lock
def work(dic,lock):
    with lock:#必须加锁才能保证数据的安全
        dic['count'] -=1
if __name__ == '__main__':
    lock = Lock()
    m = Manager()
    dic = m.dict({'count':100})#设置可共享数据
    p_L= []
    for i in range(100):
        p = Process(target=work,args=(dic,lock))
        p_L.append(p)
        p.start()
    for p in  p_L:
        p.join()
    print(dic)

4.进程池(Pool):方便了系统调用,节省了时间,实现并发效果

from multiprocessing import Process,Pool
import time
def func(i):
    i * i
    return 'i'*i
if __name__ == '__main__':
    start = time.time()
    p = Pool(4)#设置要开启进程数 默认为cpu的个数
    for i in range(50):
        p.apply_async(func,(i,))#异步提交 apply提交 async异步
    p.close()#关闭进程池 不允许再继续向这个池子添加任务了
    p.join()#阻塞,直到已经被提交的进程池中的任务全部结束
    print(time.time()-start)

返回值的获得

from multiprocessing import Pool
def func(i):
    i * i
    return 'i'*i
if __name__ == '__main__':
    p = Pool()
    ret_l = []
    for i in range(20):
        ret = p.apply_async(func,(i,))
        ret_l.append(ret)
        print(ret.get())
    # for ret in ret_l:
        print(ret.get())#获取返回值的时候必须是ret.get()
将返回值加入列表中循环打印

同步调用:

import os
import time
import random
from multiprocessing import Pool
def func(i):
    time.sleep(random.random())
    print(i,os.getpid())
if __name__ == '__main__':
    p = Pool()
    for i in range(20):
        ret = p.apply(func,(i,))

同步调用的时候 第一个进程执行完结束后才能执行,遇到io阻塞后,后面的程序都会被阻塞

Pool使用map的方法:

import time
from multiprocessing import Pool
def func(i):
    return 'i' * i
if __name__ == '__main__':
    p = Pool()
    ret_l = p.map(func,range(20))#第二个为可迭代的对象 得到结果是一个列表
    #map就是简单的appli_async的方式,并内置了close和join的功能
    for ret in ret_l:
        print(ret)

回调函数callback