36、进程的其他方法

1、守护进程：守护进程会随着主进程的代码的结束而结束

　　　守护进程的作用：会随着主进程的代码执行结束而结束，不会等待其他子进程

　　　守护进程要在start之前设置，在守护进程（也是个子进程）中，不能再开启子进程。

import time
from multiprocessing import Process
def func():
    print('--'*10)
    time.sleep(15)
    print('--'*10)

def cal_time():
    while True:
        time.sleep(1)
        print('过去了1秒')

if __name__ == '__main__':
    p = Process(target=cal_time)
    p.daemon = True     # 一定在开启进程之前设置
    p.start()
    p2 = Process(target=func)  # 15s
    p2.start()
    for i in range(100):    # 10s
        time.sleep(0.1)
        print('*'*i)
    p2.join()

 

 2、锁Lock：在并发编程中，为了保证数据安全。加上锁之后，每次需要等待数据被访问完之后，才能继续被其他应用访问。

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

def search(i):
    with open('ticket') as f:
        print(i,json.load(f)['count'])

def get(i):
    with open('ticket') as f:
        ticket_num = json.load(f)['count']
    time.sleep(random.random())
    if ticket_num > 0:
        with open('ticket','w') as f:
            json.dump({'count':ticket_num-1},f)
        print('%s买到票了'%i)
    else:
        print('%s没票了'%i)

def task(i,lock):
    search(i)   # 查看票
    lock.acquire()                  #需要锁
    get(i)      # 抢票
    lock.release()               #释放锁

if __name__ == '__main__':
    lock = Lock()            #实例化锁
    for i in range(20):  # 20个人同时抢票
        p = Process(target=task,args=(i,lock))
        p.start()

3、信号量：一把钥匙多个锁，可以允许几个进程同时访问数据（数量是有限制的）

from multiprocessing import Semaphore
from multiprocessing import Process
import time
import random
def sing(i,sem):
    sem.acquire()
    print('%d进入KTV'%i)
    time.sleep(random.randint(1,10))
    print('%d离开ktv'%i)
    sem.release()

if __name__ =='__main__':
    sem=Semaphore(4)
    for i in range(20):
        Process(target=sing,args=(i,sem)).start()

类似迷你唱吧