from threading import Thread,Lock
import os,time
def work():global nlock.acquire()temp=ntime.sleep(0.1)n=temp-1lock.release()
if __name__ == '__main__':lock=Lock()n=100l=[]for i in range(100):p=Thread(target=work)l.append(p)p.start()for p in l:p.join()print(n) #结果肯定为0，由原来的并发执行变成串行，牺牲了执行效率保证了数据安全

from threading import Thread,Lock
import time
mutexA=Lock()
mutexB=Lock()class MyThread(Thread):def run(self):self.func1()self.func2()def func1(self):mutexA.acquire()print('\033[41m%s 拿到A锁\033[0m' %self.name)mutexB.acquire()print('\033[42m%s 拿到B锁\033[0m' %self.name)mutexB.release()mutexA.release()def func2(self):mutexB.acquire()print('\033[43m%s 拿到B锁\033[0m' %self.name)time.sleep(2)mutexA.acquire()print('\033[44m%s 拿到A锁\033[0m' %self.name)mutexA.release()mutexB.release()if __name__ == '__main__':for i in range(10):t=MyThread()t.start()'''
Thread-1 拿到A锁
Thread-1 拿到B锁
Thread-1 拿到B锁
Thread-2 拿到A锁
然后就卡住，死锁了
'''

from threading import Thread,Semaphore
import time,randomsm=Semaphore(5)def task(name):sm.acquire()print('%s正在上厕所'%name)time.sleep(random.randint(1,3))sm.release()if __name__ == '__main__':for i in range(20):t=Thread(target=task,args=('路人%s'%i,))t.start()

线程的一个关键特性是每个线程都是独立运行且状态不可预测。如果程序中的其 他线程需要通过判断某个线程的状态来确定自己下一步的操作,这时线程同步问题就会变得非常棘手。为了解决这些问题,我们需要使用threading库中的Event对象。 对象包含一个可由线程设置的信号标志,它允许线程等待某些事件的发生。在 初始情况下,Event对象中的信号标志被设置为假。如果有线程等待一个Event对象, 而这个Event对象的标志为假,那么这个线程将会被一直阻塞直至该标志为真。一个线程如果将一个Event对象的信号标志设置为真,它将唤醒所有等待这个Event对象的线程。如果一个线程等待一个已经被设置为真的Event对象,那么它将忽略这个事件, 继续执行

from threading import Thread,Event
import timeevent=Event()def light():print('红灯正亮着')time.sleep(3)event.set()#绿灯亮def car(name):print('车%s正在等绿灯'%name)event.wait()#等灯绿print('车%s通行'%name)if __name__ == '__main__':#红绿灯t1=Thread(target=light)t1.start()#车for i in range(10):t=Thread(target=car,args=(i,))t.start()