一、开启进程的两种方法

方法一



from multiprocessing import Process
import time


def task(name):
    print('%s is running'%name)
    time.sleep(3)
    print('%s is done'%name)


if __name__ == '__main__':
    p=Process(target=task,args=('egon',))#p=Process(target=task,kwargs=['name':'egon'])
    p.start()
    print('主程序')



 

方法二



from multiprocessing import Process
import time

class Myprocess(Process):
    def __init__(self,name):
        super().__init__()
        self.name=name

    def run(self):
        print('%s is running'%self.name)
        time.sleep(3)
        print('%s is done'%self.name)


if __name__ == '__main__':
    p=Myprocess('egon')
    p.start()
    print('主程序')



 

二、join方法



主线程等待p终止（强调：是主线程处于等的状态，而p是处于运行的状态）。需要强调的是，p.join只能join住start开启的进程



from multiprocessing import Process
import time


def task(name,n):
    print('%s is running'%name)
    time.sleep(n)
    print('%s is done'%name)


if __name__ == '__main__':
    p1=Process(target=task,args=('p1',1))
    p2 = Process(target=task, args=('p2', 2))

    p1.start()
    p2.start()

    p1.join()
    p2.join()
    print('主程序')



 

 

三、进程之间内存空间互相隔离

　　虽然进程之间是空间上的复用，但是在内存中其实每个进程之间都是在物理层面上隔开的，接下来就用代码来验证



from multiprocessing import Process


n=100
def task():
    global n
    n=0
    print('子进程n=',n)#0


if __name__ == '__main__':
    p1=Process(target=task)
    p1.start()
    p1.join()
    print('主进程n=',n)#100



 

四、进程对象其他相关的属性或方法

1.pid：进程的唯一ID号
    1.current_process().pid:当前进程的ID号
    2.os.getpid:当前进程的ID号
    3.os.getppid:当前进程的父进程ID号
2.name:当前进程的name
3.p.terminate():强制终止进程p
4.p.is_alive():如果p仍然运行，返回True

五、僵尸进程与孤儿进程

僵尸进程　

一个进程使用fork创建子进程，如果子进程退出，而父进程并没有调用wait或waitpid获取子进程的状态信息，那么子进程的进程描述符仍然保存在系统中。这种进程称之为僵尸进程。

孤儿进程　

一个父进程退出，而它的一个或多个子进程还在运行，那么那些子进程将成为孤儿进程。孤儿进程将被init进程(进程号为0)所收养，并由init进程对它们完成状态收集工作。

六、守护进程

本质就是一个"子进程",该"子进程"的生命周期<=被守护进程的生命周期



from multiprocessing import Process
import time


def task(name):
    print('%s is 活着'%name)
    time.sleep(3)
    print('%s is 死了'%name)


if __name__ == '__main__':
    p=Process(target=task,args=('egon',))
    p.daemon=True
    p.start()
    time.sleep(1)
    print('主正在死')



 

七、互斥锁

进程之间数据不共享,但是共享同一套文件系统,所以访问同一个文件,或同一个打印终端,是没有问题的,

而共享带来的是竞争，竞争带来的结果就是错乱，如何控制，就是加锁处理



import json
import time,random
from multiprocessing import Process,Lock

def search(name):
    with open('db.json','rt',encoding='utf-8') as f:
        dic=json.load(f)
    time.sleep(1)
    print('%s 查看到余票为 %s' %(name,dic['count']))

def get(name):
    with open('db.json','rt',encoding='utf-8') as f:
        dic=json.load(f)
    if dic['count'] > 0:
        dic['count'] -= 1
        time.sleep(random.randint(1,3))
        with open('db.json','wt',encoding='utf-8') as f:
            json.dump(dic,f)
            print('%s 购票成功' %name)
    else:
        print('%s 查看到没有票了' %name)

def task(name,mutex):
    search(name) #并发
    mutex.acquire()
    get(name) #串行
    mutex.release()

    # with mutex:
    #     get(name)

if __name__ == '__main__':
    mutex = Lock()
    for i in range(10):
        p=Process(target=task,args=('路人%s' %i,mutex))
        p.start()
        # p.join() # join只能将进程的任务整体变成串行