进程中的应用

#守护进程
from multiprocessing import Process
import time

def task():
    print('zi run')
    #time.sleep(3)
    print('zi over')

if __name__ == '__main__':
    p=Process(target=task)

    p.daemon=True    #将这个进程设置为了守护进程
    p.start()

    print('主 start')
    time.sleep(6)
    print('主over')
 -------------------------     
主 start
zi run
zi over
主over

#进程安全问题
from multiprocessing import Process
def task1():
    for i in range(1000):
        1+1
    for i in range(1000):
        print("-------name is nick")
        print("-------gender is girl")
        print("-------age is 18")
def task2():
    for i in range(1000):
        1+2
    for i in range(1000):
        print("+++++++++name is tank")
        print("++++++++++gender is man")
        print("++++++++++age is 20")

if __name__ == '__main__':

    p1=Process(target=task1)
    p2=Process(target=task2)

    p1.start()
    p1.join()
    p2.start()

#互斥锁
from multiprocessing import Lock ,Process
import time ,random
def task1(mutex):
    #假设这个不是访问公共资源的，那么还可以并发执行

    for i  in range(10000):
        print(1)

    mutex.acquire()   #就是加锁
    time.sleep(random.random())
    print("------name is nick")
    time.sleep(random.random())
    print("-------gender is boy")
    time.sleep(random.random())
    print("--------age is 18")

    mutex.release()

def task2(mutex):
    for i in range(10000):
        print(2)

    mutex.acquire()
    time.sleep(random.random())
    print("+++++++name is bgon")
    time.sleep(random.random())
    print("+++++++gender is oldboy")
    time.sleep(random.random())
    print("+++++++age is 56")
    mutex.release

if __name__ == '__main__':
    mutex=Lock()
    print("创建锁了")

    p1=Process(target=task1,args=(mutex,))
    p2=Process(target=task2,args=(mutex,))

    p1.start()
    p2.start()

#锁的案例----->抢票   其中文件里的count要加引号
from multiprocessing import Process,Lock
import json
def shou():
    with open("db.json")as f:
        data =json.load(f)
        print("剩余票数",data['count'])
def buy():
    with open("db.json")as f:
        data =json.load(f)
        if data['count']>0:
            data['count']-=1
            with open("db.json",'wt')as f2:
                json.dump(data,f2)
                print('抢票成功')
def task(mutex):
    shou()
    mutex.acquire()
    buy()
    mutex.release()

if __name__ == '__main__':
    mutex=Lock()
    for i in range(5):
        p=Process(target=task,args=(mutex,))
        p.start()
 打印结果
剩余票数 1
抢票成功!
剩余票数 0
剩余票数 0
剩余票数 0
剩余票数 0

#manager的使用
from multiprocessing import Process,Lock,Manager
import time
def task(data,Lock):
    lock.acquire()
    num=data[0]
    time.sleep(0.1)
    data[0]=num-1
    lock.release()
    print('子over')
if __name__ == '__main__':
    d=[100]
    m=Manager()  #创建一个管理器
    syncdict = m.list(d)   #让管理器创建一个进程同步的字典

    #创建一个锁
    lock=Lock()
    ps=[]

    for i in range(10):
        p=Process(target=task,args=(syncdict,lock))
        p.start()
        ps.append(p)
    for p in ps:
        p.join()

    print(d)
    print(syncdict)

    打印结果
子over
子over
子over
子over
子over
子over
子over
子over
子over
子over
[100]
[90]

#进程队列
from multiprocessing import Queue
q=Queue(2)   #创建队列，并且同时只存储2个元素
q.put(1)
q.put(2)
#q.put(3,block=True,timeout=3)
# #默认是阻塞的，当容器中没有位置了，就是阻塞，直到有人从里面取走元素为止
print(q.get())
print(q.get())
print(q.get(block=True,timeout=3))
#默认是阻塞的，当容器中没有位置就阻塞，直到有人存入元素为

#处理万能异常
import traceback
try:
    raise Exception("adasda")
except Exception as e:
    traceback.print_exc()
    print(e)
print('over'

1.将双方分开来.一方专门负责生成,一方专门负责处理
2.生产者完成后放入容器,消费者从容器中取出数据
做饭 和 吃饭进程
import time
import random
from multiprocessing import Process,Queue
def eat(q):
    for i in range(10):
        rose=q.get()
        time.sleep(random.randint(0,2))
        print(rose,"吃完了")
def make_rose(q):
    for i in range(10):
        time.sleep(random.randint(0,2))
        print('第%s盘蛋炒饭制作完成'%i)
        rose="第%s盘蛋炒饭"%i
        q.put(rose)
if __name__ == '__main__':
    q =Queue()
    make_p =Process(target=make_rose,args=(q,))
    eat_p=Process(target=eat,args=(q,))

    make_p.start()
    eat_p.start()