进程

创建进程方式一

from multiprocessing import Process
import time

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


#创建进程(伪代码)

#注意：在Windows系统中，创建进程会将代码以模块的方式从头到尾加载一遍
#一定要写在if __name__ == '__main__':代码块里面
#强调：函数名一旦加括号，执行优先级是最高的！！！！，立刻执行
if __name__ == '__main__':
    p1=Process(target=task,args=('egon',))#task不要加（）   只是实例化了一个Process对象
    #子进程
    p1.start()  #告诉操作系统创建一个进程，1.类似异步  2.去硬盘调取数据放到内存空间，需要时间
    print('主')

from multiprocessing import Process

import time

def task():
    # print('runnning')
    # time.sleep(1)
    # print('ending')
    x=10
    y=20
    return x,y


if __name__ == '__main__':
    p1=Process(target=task)
    p1.start()
    p1.join()
    def add(n1,n2):
        return n1+n2
    x=task()
    a=add(*x)
    print(a)

创建进程方式二

from multiprocessing import Process
import time

class Myprocess(Process):

    def __init__(self,name):
        super().__init__()
        self.name=name

    def run(self):#必须叫run方法
        print('%s is running'%self.name)
        time.sleep(1)
        print('%s is end'%self.name)


if __name__ == '__main__':
    obj=Myprocess('egon')
    obj.start()
    print('主')

进程的join方法

import time
from multiprocessing import Process


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



if __name__ == '__main__':
    p1=Process(target=task,args=('egon',2))
    p2 = Process(target=task, args=('Tom',3))
    p3 = Process(target=task, args=('Kevin',4))
    start=time.time()
    p1.start()#只是告诉操作系统需要创建进程，注意注意
    p2.start()
    p3.start()
    p3.join()#只是让主进程等待子进程，不影响子进程干活！！！
    p1.join()
    p2.join()

    time.sleep(4)#主要是子进程耗时的时间不知道多少，所以不可以
    # 想要子进程结束在走主程序（拿到子进程的一些数据）
    p1.join()  #主进程等待子进程结束，才可以继续运行
    print('主',time.time()-start)



#join的作用仅仅只是让主进程等待子进程的结束，不会影响子进程的运行
if __name__ == '__main__':
    p_list=[]
    for i in range(3):
        p=Process(target=task,args=('子进程%s'%i,i))
        p.start()  #本质上是调用了Process类的run方法
        # p.join()
        p_list.append(p)
    for i in p_list:
        i.join()
    print('主')


from multiprocessing import Process

import time

def run():
    print('333')



def task():
    print('11111')
    time.sleep(1)
    print('22222')


if __name__ == '__main__':
    p1=Process(target=run)
    p1.start()
    p1.join()
    print(主')

from multiprocessing import Process
import time
class Myprocess(Process):
    def __init__(self,i):
        super().__init__()
        self.i=i
    def run(self):
        print('%s is running'%self.i)
        time.sleep(1)
        print('%s is ending'%self.i)
    def task(self):
        # return self.name
        print('aaaaaaa')


if __name__ == '__main__':
    p1=Myprocess('egon')  #创建了一个子进程（就是要实现并发的效果）
    # p1.task()
    p1.start()#本质上走的就是run方法
    # p1.task()
    p1.join()  #是将并发变成了串行

    print('555555')

if __name__ == '__main__':
    p_list=[]
    for i in range(5):
        p=Myprocess(i)
        p.start()
    p.join()
    print('主')

进程间的互斥锁

#自定义买火车票
是将进程并发变成了串行，牺牲了效率，但是提高了数据的安全性

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


def search(i):
    #查票
    with open('info','r',encoding='utf-8') as f:
        data=json.load(f)
        print('%i用户查询余票为%s'%(i,data['ticket']))

def buy(i):
    #买票之前再次查询
    with open('info','r',encoding='utf-8') as f:
        data=json.load(f)
        # mutex.acquire()
        time.sleep(random.randint(1,3))  #模拟网络延迟

        if data['ticket']>0:#判断票数是否为空，不为空买
            data['ticket']-=1#买票一张
            with open('info','w',encoding='utf-8') as f:
                json.dump(data,f)
            print('用户购票成功')
            # mutex.release()
        else:
            print('%s用户查询票数为0'%i)


def run(i,mutex):
    search(i)
    mutex.acquire()#设置锁，第一个用户抢到锁其他用户就会被夯住在原地
    buy(i)
    mutex.release()#只有锁释放了其他进程才可以抢

if __name__ == '__main__':
    mutex = Lock()
    for i in range(10):
        p=Process(target=run,args=(i,mutex))
        p.start()

守护进程

#父进程死掉子进程也会死掉,本质上也是一个‘子进程’，只不过会随着父进程的死而死
from multiprocessing import Process
import time
def task(name):
    print('%s is running'%name)
    time.sleep(1)
    print('%s is ending'%name)

if __name__ == '__main__':
    p1=Process(target=task,args=('妃子',))
    p1.daemon=True
    p1.start()
    time.sleep(1)
    print('皇帝正在死亡')

进程就数据隔离

#记住  进程与进程之间的数据是隔离的！！！

from  multiprocessing import Process

x=100

def task():
    global x
    x=10

if __name__ == '__main__':
    p=Process(target=task)
    p.start()
    p.join()
    print(x)    #子进程是没有权利修改父进程的，也就是说进程与进程之间的数据是隔离开的，每一个进程都是一个独立的空间