守护进线程，互斥锁，信号量，队列，死锁递归锁等

守护进程：

from multiprocessing import Process
import os,time,random

def task():
    print('%s is running' %os.getpid())
    time.sleep(2)
    print('%s is done' %os.getpid())
    # p = Process(target=time.sleep, args=(3,))
    # p.start()

if __name__ == '__main__':
    p=Process(target=task)
    p.daemon = True #1、必须在p.start()之前 2：守护进程不能开启子进程
    p.start()
    # p.join()
    print('主')
    '''
    举例说明守护进程的应用场景：
        假设有两个任务要干，要玩出并发的效果，使用进程的话可以让主进程
        执行一个任务，然后开启一个子进程执行一个任务。

        如果这两个任务毫无关系，那么就像上面这么做就可以
        如果主进程的任务在执行完毕后，子进程的任务没有存在的意义了
        那么该子进程应该在开启之前就被设置成守护进程
    '''

迷惑人的例子

主进程代码运行完毕,守护进程就会结束

from multiprocessing import Process
from threading import Thread
import time
def foo():
    print(123)
    time.sleep(1)
    print("end123")

def bar():
    print(456)
    time.sleep(3)
    print("end456")

if __name__ == '__main__':
    p1=Process(target=foo)
    p2 = Process(target=bar)

    p1.daemon=True
    p1.start()
    p2.start()
    print("main-------") #打印该行则主进程代码结束,则守护进程p1应该被终止,可能会有p1任务执行的打印信息123,
因为主进程打印main----时,p1也执行了,但是随即被终止

互斥锁三个例子：

from multiprocessing import Process,Lock
import os,time,random   # 
互斥锁就是给整串行，比join好点，可以控制锁的时间。
def task(mutex):
    mutex.acquire()
    print('%s print 1'%os.getpid())
    time.sleep(random.randint(1,2))
    print('%s print 2' % os.getpid())
    time.sleep(random.randint(1, 2))
    print('%s print 3' % os.getpid())
    time.sleep(random.randint(1, 2))
    mutex.release()
if __name__ == '__main__':
    mutex = Lock()
    p1 = Process(target=task,args=(mutex,))
    p2 = Process(target=task,args=(mutex,))
    p3 = Process(target=task,args=(mutex,))
    p1.start()
    p2.start()
    p3.start()
##########################################################
from multiprocessing import Process,Lock
import os,time,random,json
def search():
    with open('db.txt',encoding='utf-8') as f:
        dic=json.load(f)
        print('%s 剩余票数 %s'%(os.getpid(),dic['count']))
def get():
    with open('db.txt',encoding='utf-8') as read_f:
        dic = json.load(read_f)
    if dic['count'] > 0:
        dic['count'] -= 1
        time.sleep(random.randint(1,3))
        with open('db.txt','w',encoding='utf-8')as write_f:
            json.dump(dic,write_f)
            print('%s 抢票成功'%os.getpid())
def task(mutex):
    search()
    mutex.acquire()
    get()
    mutex.release()

if __name__ == '__main__':
    mutex = Lock()
    for i in range(20):
        p = Process(target=task,args=(mutex,))
        p.start()
########################################################
from threading import Thread,Lock
import time
n = 100
def task(mutex):
    global n
    with mutex:    ### 相当于 那 两行代码
        temp = n
        time.sleep(0.01)
        n = temp-1
if __name__ == '__main__':
    mutex = Lock()
    t_l = []
    for i in range(100):
        t = Thread(target=task,args=(mutex,))
### t = Thread(target=task)   # 因为是线程资源共享，所以不用传参args=(mutex,)
        t_l.append(t)
        t.start()
    for i in t_l:
        i.join()
    print(n)    ############ 0

信号量：

from multiprocessing import Process,Semaphore
# from threading import Thread,Semaphore
import time,random,os

def task(sm):
    with sm:
        print('%s 上厕所' %os.getpid())
        time.sleep(random.randint(1,3))

if __name__ == '__main__':
    sm=Semaphore(3)
    for i in range(10):
        p=Process(target=task,args=(sm,))
        p.start()

==============================================================================================================================

ipc机制 : 进程之间通信,指的是用内存空间共享，来实现进程之间通信：

①管道

②队列

frommultiprocessingimportQueue#进程队列

q=Queue(3)    
若 定义为3，则放3个拿3个，超出则进程结束不了，一直等着。
q.put({'a':1})
q.put('xxxxx')
q.put(3)
q.put(4)

print(q.get())
print(q.get())
print(q.get())
print(q.get())

importqueue#线程队列

队列：先进先出

q=queue.Queue(3)
q.put({'a':1})
q.put('xxxxx')
q.put(3)
q.put(4)

print(q.get())
print(q.get())
print(q.get())
print(q.get())

优先级队列:数字越小优先级越高

q=queue.PriorityQueue(3)
q.put((10,{'a':1}))
q.put((-1,'xxxxx'))
q.put((0,3))
# q.put(4)

print(q.get())
print(q.get())
print(q.get())
print(q.get())

堆栈：先进后出

q=queue.LifoQueue(3)
q.put({'a':1})
q.put('xxxxx')
q.put(3)
# q.put(4)

print(q.get())
print(q.get())
print(q.get())
print(q.get())

死锁/递归锁

from threading import Thread,Lock,RLock   # RLock 就是说可以多次拿锁。
import time
# mutexA=mutexB=Lock()
mutexA=mutexB=RLock()   
###两个锁的时候会出现死锁，一个拿到锁却没释放
class MyThread(Thread):
    def run(self):
        self.f1()
        self.f2()

    def f1(self):
        mutexA.acquire()
        print('%s 拿到A锁' %self.name)

        mutexB.acquire()
        print('%s 拿到B锁' %self.name)
        mutexB.release()

        mutexA.release()

    def f2(self):
        mutexB.acquire()
        print('%s 拿到B锁' % self.name)
        time.sleep(0.1)
        mutexA.acquire()
        print('%s 拿到A锁' % self.name)
        mutexA.release()

        mutexB.release()

if __name__ == '__main__':
    for i in range(10):
        t=MyThread()
        t.start()

终身美丽 --- 郑秀文