python process

1	`原文：<strong>https://www.cnblogs.com/LY-C/p/9145729.html</strong>`

进程：资源分配的基本单位，进程数量为cpu核数+1，os.cpu_count()。计算密集时，使用进程

守护进程随着主进程的最后一句代码结束而结束

使用process模块可以创建进程

from multiprocessing import Process
p = Process(target,args,name)
target：表示调用对象，即子进程要执行的任务
args：表示调用对象的位置参数”元组“
name：进程的名字

　　方法

p.start()：启动一个子进程，系统决定什么时候调用p.run() 
p.run():立即运行子进程
p.terminate():强制终止进程p，不会进行任何清理操作，如果p创建了子进程，该子进程就成了僵尸进程，使用该方法需要特别小心这种情况。如果p还保存了一个锁那么也将不会被释放，进而导致死锁
p.is_alive():判断p进程是否还存在，如果p仍然运行，返回True
p.join([timeout]):异步变同步，让主进程等待子进程执行完毕（强调：是主线程处于等的状态，而p是处于运行的状态）。timeout是可选的超时时间，需要强调的是，p.join只能join住start开启的进程，而不能join住run开启的进程  

　　多进程启动

#如果好多进程都要启动，代码太长可以写成这样
p_list = [p1,p2,p3,p4,p5]
[i.start() for i in p_list]

　　属性

p.daemon：默认值为False，如果设为True，代表p为后台运行的守护进程，当p的父进程终止时，p也随之终止，并且设定为True后，p不能创建自己的新进程，必须在p.start()之前设置
p.name:进程的名称
p.pid：进程的pid

　　示例

from multiprocessing import Process
import time
 
def func(name):
    print('son 的名字是 %s '%name)
    time.sleep(5)
    print('这里是son')
 
if __name__ == '__main__':
    p = Process(target = func,args=('xxx',))
    p.start()
    time.sleep(2)
    p.join()# 代码执行到这里，主进程main会停止等待子进程执行完毕才继续
    print('这里是father')

　　锁机制

from multiprocessing import Lock
l = Lock()   #创建一个锁
 
l.acquire()   # 加锁
 
l.release()   # 释放锁

　　信号机制

from multiprocessing import Semaphore
l = Semaphore(n)    #创建锁,n是指初始化一把锁配几把钥匙，一个int型
 
l.acquire()   #加锁，可以加n把锁
 
l.release()   #释放锁
 
#信号量机制比锁机制多了一个计数器，这个计数器是用来记录当前剩余几把钥匙的。
#当计数器为0时，表示没有钥匙了，此时acquire()处于阻塞。
#对于计数器来说，每acquire一次，计数器内部就减1，release一次，计数器就加1

　　事件机制

from multiprocessing import Event
         
e = Event()   #创建事件
e.wait()   #判断is_set的bool值，如果bool为True，则非阻塞，bool值为False，则阻塞
e.set()    #将is_set()设为True
e.clear()  # 将is_set()设为False
 
 
e.is_set() # 标识
# 事件是通过is_set()的bool值，去标识e.wait() 的阻塞状态
# 当is_set()的bool值为False时，e.wait()是阻塞状态
# 当is_set()的bool值为True时，e.wait()是非阻塞状态
# 当使用set()时，是把is_set的bool变为True
# 当使用clear()时，是把is_set的bool变为False

　　队列

#先进先出
from multiprocessing import Queue
 
q = Queue([n])  #n为该队列最多元素的个数，省略不限制
 
q.get( [ block [ ,timeout ] ] ) 
#返回q中的一个项目。如果q为空，此方法将阻塞，直到队列中有项目可用为止。
#block用于控制阻塞行为，默认为True. 如果设置为False，将引发Queue.Empty异常#timeout是可选超时时间，用在阻塞模式中。如果在指定的时间间隔内没有项目可用，将引发Queue.Empty异常。
 
q.get_nowait( )   #同q.get(False)方法。
 
q.put(item [, block [,timeout ] ] ) 
#将item放入队列。如果队列已满，此方法将阻塞至有空间可用为止。
#block控制阻塞行为，默认为True。如果设置为False，将引发Queue.Empty异常#timeout指定在阻塞模式中等待可用空间的时间长短。超时后将引发Queue.Full异常。
 
q.qsize()   #返回队列中目前项目的正确数量。
q.empty()  #如果调用此方法时 q为空，返回True。
q.full()    #如果队列已满，返回为True. 

　　进程间共享内存

from multiprocessing import Manager
m = Manager()
num = m.dict({键 : 值})
num = m.list([1,2,3])

　　进程池

from multiprocessing import Pool
p = Pool(5)  #创建进程池，限定进程个数
 
p.apply(func,args=(,)) #同步执行线程,阻塞
 
p.apply_async(func,args=(,),callback=func2)  #异步执行线程，非阻塞
#func函数返回的值，传给了callback后面接的函数，进一步执行
 
p.map(func,iter)   #异步执行，iter为可迭代对象
 
p.close()   #不在向进程池中添加任务，同步不需要使用
 
p.join()   #等待进程池执行完任务，同步不需要使用