Python 进程

一、定义：

　　正在进行的一个过程或者说一个任务。而负责执行任务则是cpu。

二、进程的创建方式：

　　都是通过multiprocessing 的Process进行创建的

　　1、第一种

from multiprocessing import Process
import time
def work(name):
    print('task <%s> is runing' %name)
    time.sleep(2)
    print('task <%s> is done' % name)

if __name__ == '__main__':
    # Process(target=work,kwargs={'name':'egon'})
    p1=Process(target=work,args=('egon',))
    p2=Process(target=work,args=('alex',))
    p1.start()
    p2.start()
    print('主')

　　2、第二种

from multiprocessing import Process
import time
class MyProcess(Process):
    def __init__(self,name):
        super().__init__()
        self.name=name

    def run(self):
        print('task <%s> is runing' % self.name)
        time.sleep(2)
        print('task <%s> is done' % self.name)



if __name__ == '__main__':
    p=MyProcess('egon')
    p.start()

    print('主')

三、进程中的join方法，当进行进程.join的时候意思是主进程等，等待进程运行结束，再结束

from multiprocessing import Process
import time
def work(name):
    print('task <%s> is runing' %name)
    time.sleep(3)
    print('task <%s> is done' % name)

if __name__ == '__main__':
    p1=Process(target=work,args=('egon',))
    p2=Process(target=work,args=('alex',))
    p3=Process(target=work,args=('yuanhao',))

    # p1.start()
    # p2.start()
    # p3.start()
    #
    # p1.join() #主进程等，等待p1运行结束
    # p2.join() #主进程等，等待p2运行结束
    # p3.join() #主进程等，等待p3运行结束

    p_l = [p1, p2, p3]
    for p in p_l:
        p.start()

    for p in p_l:
        p.join()

    print('主')

四、Process对象的其它方法

　　其中的.pid获取进程的id,.name获取进程的名称，.is_alive是否存活，.terminate强制终止

from multiprocessing import Process
import time,os
def work():
    print('parent:%s task <%s> is runing' %(os.getppid(),os.getpid()))
    time.sleep(1000)
    print('parent:%s task <%s> is done'  %(os.getppid(),os.getpid()))


if __name__ == '__main__':
    p1=Process(target=work)
    p1.start()
    p1.terminate()  # 强制终止p1
    # time.sleep(3)
    print(p1.is_alive()) # p1是否存活
    print(p1.name) # p1的线程名
    print(p1.pid) # p1 的id
    print('主',os.getpid(),os.getppid())
    time.sleep(10000)

五、守护进程

　　守护进程也就是主进程代码运行完毕,守护进程就会结束，把进程对象的的 daemon设为True，例 p1.daemon=True

#主进程代码运行完毕,守护进程就会结束
from multiprocessing import Process
import time
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()
    print("main-------") #打印该行则主进程代码结束,则守护进程p1应该被终止,可能会有p1任务执行的打印信息123,因为主进程打印main----时,p1也执行了,但是随即被终止

六、进程同步锁

　　锁需要导入multiprocessing 的Lock，得到锁，在执行进程的函数中每那个进程执行函数就独占加上锁等处理完后再解开锁让其它进程进程进来处理

from multiprocessing import Process,Lock
import time
def work(name,mutex):
    # 加锁
    mutex.acquire()
    print('task <%s> is runing' %name)
    time.sleep(2)
    print('task <%s> is done' % name)
    # 解锁
    mutex.release()

# if __name__ == '__main__':
#     得到锁
    mutex=Lock()
    p1=Process(target=work,args=('egon',mutex))
    p2=Process(target=work,args=('alex',mutex))
    p1.start()
    p2.start()
    print('主')

同步锁模拟抢票实例：

import json
import os
import time
from multiprocessing import Process,Lock
def search():
    dic=json.load(open('db.txt'))
    print('33[32m[%s] 看到剩余票数<%s>33[0m' %(os.getpid(),dic['count']))
def get_ticket():
    dic = json.load(open('db.txt'))
    time.sleep(0.5) #模拟读数据库的网络延迟
    if dic['count'] > 0:
        dic['count']-=1
        time.sleep(0.5)  # 模拟写数据库的网络延迟
        json.dump(dic,open('db.txt','w'))
        print('33[31m%s 购票成功33[0m' %os.getpid())
def task(mutex):
    search()
    mutex.acquire()
    get_ticket()
    mutex.release()
if __name__ == '__main__':
    mutex=Lock()
    for i in range(10):
        p=Process(target=task,args=(mutex,))
        p.start()

七、共享数据

　　可以通过导入multiprocessing 的Manager，用Manager获得对象，用对象下的数据类型进行数据数据如下：

from multiprocessing import Process,Manager,Lock

def task(dic,mutex):

    with mutex:
        dic['count']-=1

if __name__ == '__main__':
    mutex=Lock()
    m=Manager()
    dic=m.dict({'count':100}) #创建共享数据
    p_l=[]
    for i in range(100):
        p=Process(target=task,args=(dic,mutex))
        p_l.append(p)
        p.start()

    for p in p_l:
        p.join()
    print(dic)