• 创建进程

创建进程 一

from multiprocessing import Process
import time
def task(name):
    print('%s 开始')
    time.sleep(3)
    print('%s 完事')

#创建进程需要在mian下创建
#不然电脑直接蹦一直创建
if __name__ == 'main':
    p = Process(target=task,args=('srx',))
    p.start() #开启进程
    print('master')

创建进程 二

class OwnProcess(Process):
    def run(self):
        print('%s 开始')
        time.sleep(3)
        print('%s 完事')
if __name__ == '__main__':
    P = OwnProcess()
    P.start()
    print('master')

　总结：创建进程是在内存中申请一个独立内存地址跑代码，默认进程之间无法通信

• join

from multiprocessing import Process
import time
def task(name):
    print('%s 开始'%name)
    time.sleep(3)
    print('%s 完事'%name)
if __name__ == '__ main__':
    p = Process(target=task,args=('srx',))
    p.start() #开启进程
    p.join()  #等待子进程完事，在主进程上
    print('master')

def task(name,i):
    print('%s 开始'%name)
    time.sleep(i)
    print('%s 完事'%name)


if __name__ == '__ main__':
    p_list = []
    for i in range(1,4):
        p=Process(target=task, args=('srx%s' %i,i))
        p.start()
        p_list.append(p)
    for s in p_list:     #开启多个子进程，同时进行谁快谁先完事，然后执行master
        s.join()
    print('master')

子进程之间无法共享资源

age = 10
def task():
    global age 
    age =20
if __name__ == '__ main__':
    p  =Process(target=task)
    p.join()
    #进程之间独立运行资源默认无法共享 打印还是10
    print(age)

互斥锁

from multiprocessing import Process,Lock
import json
import time
import random
def search(i):
    with open ('ticket','r',encoding='utf8') as f :
        dic = json.load(f)
    print('%s用户，剩余票数%s'%(i,dic.get('tickets')))
def buy(i):
    with open ('ticket','r',encoding='utf8') as f :
        dic = json.load(f)
    time.sleep(random.randint(1,3))
    if dic.get('tickets') >0:
        dic['tickets'] -= 1
        with open('ticket', 'w', encoding='utf8') as f:
            json.dump(dic,f)
        print('%s用户，购买成功'%i)
    else:
        print('%s用户,购买失败'%i)
def run(i,lock):
    search(i)
    lock.acquire() #一把锁 谁先拿到谁先用
    buy(i)
    lock.release() #完事，解锁

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

　　并发变成了串行，减慢程序的速度，提高了数据的安全性

守护进程

p = Process()
p.daemon = True  # 将进程p设置成守护进程  这一句一定要放在start方法上面才有效否则会直接报错
p.start()

　　主进程结束，守护进程也结束

借助消息队列进程之间通信

 import queue 
q = queue.Queue
q.put() #放数据
q.get() #取数据

　生产者消费者模型

def s(name,food,q):
    for i in range(4):
        data = '%s生产%s%s个' %(name,food,i)
        time.sleep(random.randint(1,3))
        print(data)
        q.put(data)


def x(name,q):
    while True:
        food =q.get()
        time.sleep(random.randint(1,3))
        print('%s吃了%s'%(name,food))
        q.task_done()  # 告诉队列已经从队列中取出一个了

if __name__ == '__main__':
    q = JoinableQueue()
    p = Process(target=s,args=('s1','s_food',q,))
    p1= Process(target=x,args=('x1',q,))
    p.start()
    p1.daemon = True   #把消费者绑定为守护进程，这样主进程结束子进程也结束
    p1.start()
    p.join()
    q.join()  #等队列中的数据被取完了执行下面的代码