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

守护进程：

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()
终身美丽 --- 郑秀文