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

守护进程：

from multiprocessing import Processimport os,time,randomdef 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 Processfrom threading import Threadimport timedef 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,Lockimport 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,Lockimport os,time,random,jsondef 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,Lockimport timen = 100def task(mutex):    global n    with mutex:    ### 相当于 那 两行代码        temp = n        time.sleep(0.01)        n = temp-1if __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,Semaphoreimport time,random,osdef 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()

终身美丽 --- 郑秀文