1.互斥锁：
原理：将并行变成串行
精髓：局部串行，只针对共享数据修改
保护不同的数据就应该用不用的锁
from threading import Thread, Lock
import time n = 100 def task():
global n
mutex.acquire() # 效率低了 但是数据安全了
temp = n
time.sleep(0.1) # 100个线程 都拿到了100 所以就是 100个线程100-1
n = temp - 1
mutex.release() if __name__ == '__main__':
mutex = Lock()
t_l = []
for i in range(100):
t = Thread(target=task)
t_l.append(t)
t.start() for t in t_l:
t.join() print('主', n)
"""
主 99 原因： 100个线程 都拿到了100 所以就是 100个线程100-1 数据不安全 效率高但是不安全
要将并行改为串行
"""
"""
主 0 原因：效率低了 但是数据安全了
"""
2.GIL: global interpreter lock
python3 test.py
ps aux | grep test # linux
tasklist | findstr python # windows python.exe 运行python 会有几步：
1.会有一个进程，进程内存空间 python解释器的代码先加载到内存空间
2.test.py 内容加载到内存
3.解释执行；代码交给了python解释器
线程干活指向了python代码 python代码当作参数传给了解释器
线程拿到解释器的代码，拿着python代码当作参数，执行
垃圾回收线程运行解释器的代码
垃圾回收线程和某一个线程冲突了，数据不安全，
开多个进程，GIL就没影响了， cpython解释器垃圾回收线程定期启动一个
GIL:互斥锁，保证数据的安全 对CPython解释器，同一时间只有一个线程运行
GIL.acquire() 这样垃圾线程和线程就不会冲突了，这样回收机制就变得安全了
GIL.release()
python解释器，多线程有GIL存在，保证了一个进程下面多个线程的执行是一个一个执行的 有GIL与自动的锁的工作原理：
总结：
1.GIL 一个进程内的多个线程同一时间只能运行一个线程，垃圾回收线程是安全的
2.针对不同的数据，就应该加不同的锁，解释器级别的GIL锁，只能保护解释器级别的数据，
不能保护自己的数据，针对自己的共享数据还要加锁； 线程首先抢的是；GIL锁，之后才是mutex
官网：
结论：在Cpython解释器中，同一个进程下开启的多线程，同一时刻只能有一个线程执行，无法利用多核优势 GIL的存在：同一时刻，只能有一个线程在运行
多核，多进程，但进程开销大，多线程，又不能用多核 ? cpu干计算的，多个cpu
1.如果是干计算的操作，多核省时间
2.如果干IO阻塞型操作，多核没用 程序运行：都会干计算和IO操作 四个任务：
1.1个核：开多线程 ，因为多进程能用上多核
2.多核:
计算密集型：用多进程，用多核，eg:金融行业的，计算比较多,虽然多进程开销大，但多核，保证了计算快
IO密集型：用多线程，同一时间只能用一个核，1个核一个进程，多线程就在一个核上来回切和四个核来回切是一样的 现在写的软件：
网络打交道，网络的IO
IO密集型，用多线程
"""
计算密集型应该用： 多进程 效率高
"""
from multiprocessing import Process
from threading import Thread
import os,time def work():
res=0
for i in range(100000000):
res*=i if __name__ == '__main__':
l=[]
print(os.cpu_count()) #本机为8核
start=time.time()
for i in range(8):
# p=Process(target=work) #耗时8s多
p=Thread(target=work) #耗时37s多
l.append(p)
p.start()
for p in l:
p.join()
stop=time.time()
print('run time is %s' %(stop-start)) """
IO密集型：多线程 效率高
"""
from multiprocessing import Process
from threading import Thread
import threading
import os,time
def work():
time.sleep(2)
print('===>') if __name__ == '__main__':
l=[]
print(os.cpu_count()) #本机为8核
start=time.time()
for i in range(400):
# p=Process(target=work) #耗时8s多,大部分时间耗费在创建进程上
p=Thread(target=work) #耗时2s多
l.append(p)
p.start()
for p in l:
p.join()
stop=time.time()
print('run time is %s' %(stop-start))
3.死锁：
你拿着我的锁，我拿着你的锁 互斥锁：Lock()
互斥锁只能acquire一次 递归锁:RLock()
可以连续acquire多次，每acquire一次计数器+1，
只有计数为0时，才能被抢到acquire
from threading import Thread,Lock
import time mutexA=Lock()
mutexB=Lock() 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()
"""
Thread-1 拿到了A锁 # 死锁了 卡住了
Thread-1 拿到了B锁
Thread-1 拿到了B锁
Thread-2 拿到了A锁
"""
# 互斥锁只能acquire一次
# from threading import Thread,Lock
#
# mutexA=Lock()
#
# mutexA.acquire()
# mutexA.release() # 递归锁:可以连续acquire多次，每acquire一次计数器+1，只有计数为0时，才能被抢到acquire
from threading import Thread,RLock
import time mutexB=mutexA=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(2) mutexA.acquire()
print('%s 拿到了A锁' % 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-1 拿到了A锁
Thread-2 拿到了A锁
Thread-2 拿到了B锁
Thread-2 拿到了B锁
Thread-2 拿到了A锁
Thread-4 拿到了A锁
Thread-4 拿到了B锁
Thread-5 拿到了A锁
Thread-5 拿到了B锁
Thread-5 拿到了B锁
Thread-5 拿到了A锁
Thread-7 拿到了A锁
Thread-7 拿到了B锁
Thread-7 拿到了B锁
Thread-7 拿到了A锁
Thread-9 拿到了A锁
Thread-9 拿到了B锁
Thread-9 拿到了B锁
Thread-9 拿到了A锁
Thread-3 拿到了A锁
Thread-3 拿到了B锁
Thread-3 拿到了B锁
Thread-3 拿到了A锁
Thread-6 拿到了A锁
Thread-6 拿到了B锁
Thread-6 拿到了B锁
Thread-6 拿到了A锁
Thread-10 拿到了A锁
Thread-10 拿到了B锁
Thread-10 拿到了B锁
Thread-10 拿到了A锁
Thread-8 拿到了A锁
Thread-8 拿到了B锁
Thread-8 拿到了B锁
Thread-8 拿到了A锁
Thread-4 拿到了B锁
Thread-4 拿到了A锁
"""
4.信号量
信号量也是一把锁，可以指定信号量为5，对比互斥锁同一时间只能有一个任务抢到锁去执行，
信号量同一时间可以有5个任务拿到锁去执行
信号量：同一时间有多个线程在进行
from threading import Thread,Semaphore,currentThread
import time,random sm=Semaphore(1) def task():
# sm.acquire()
# print('%s in' %currentThread().getName())
# sm.release()
with sm: # 类似于sm.acquire() # 同一时间可以来3个人，1个人，或者2个人
print('%s in' %currentThread().getName())
time.sleep(random.randint(1,3)) if __name__ == '__main__':
for i in range(10):
t=Thread(target=task)
t.start()
"""
Thread-1 in
Thread-2 in
Thread-3 in Thread-4 in Thread-6 in
Thread-5 in
Thread-7 in Thread-8 in
Thread-9 in Thread-10 in
"""
5.Event:
多个线程之间同步的，一个线程告诉另一些线程可以做其他的活了
event.wait()
event.wait(2)
event.set()
event.is_set()
event.clear()
from threading import Thread,Event
import time event=Event()
# event.wait() # 等 ...直到 set
# event.set() def student(name):
print('学生%s 正在听课' %name)
# event.wait() # 学生要等7秒 才能下课
event.wait(2) # 学生等2秒 直接下课了 print('学生%s 课间活动' %name) def teacher(name):
print('老师%s 正在授课' %name)
time.sleep(7)
event.set() if __name__ == '__main__':
stu1=Thread(target=student,args=('alex',))
stu2=Thread(target=student,args=('wxx',))
stu3=Thread(target=student,args=('yxx',))
t1=Thread(target=teacher,args=('egon',)) stu1.start()
stu2.start()
stu3.start()
t1.start() # ------------------
# 设置链接的超时时间
from threading import Thread,Event,currentThread
import time event=Event() def conn():
# print('%s is connecting'%currentThread().getName())
# event.wait()
# print('%s is connected'%currentThread().getName()) n=0
while not event.is_set():
if n == 3:
print('%s try too many times' %currentThread().getName())
return
print('%s try %s' %(currentThread().getName(),n))
event.wait(0.5)
n+=1 print('%s is connected' %currentThread().getName()) def check():
print('%s is checking' %currentThread().getName())
time.sleep(5)
event.set() if __name__ == '__main__':
for i in range(3):
t=Thread(target=conn)
t.start()
t=Thread(target=check)
t.start()
"""
Thread-1 try 0
Thread-2 try 0
Thread-3 try 0
Thread-4 is checking
Thread-3 try 1
Thread-2 try 1
Thread-1 try 1
Thread-3 try 2
Thread-1 try 2
Thread-2 try 2
Thread-3 try too many times
Thread-2 try too many times
Thread-1 try too many times
"""
6.定时器：Timer
t=Timer(5,task,args=('egon',))
t.start()
t.cancel()
from threading import Timer def task(name):
print('hello %s' %name) t=Timer(5,task,args=('egon',)) # 就是起了一个线程
t.start() # ----------------------
from threading import Timer
import random class Code:
def __init__(self):
self.make_cache() def make_cache(self,interval=10):
self.cache=self.make_code()
print(self.cache)
self.t=Timer(interval,self.make_cache)
self.t.start() def make_code(self,n=4):
res=''
for i in range(n):
s1=str(random.randint(0,9))
s2=chr(random.randint(65,90))
res+=random.choice([s1,s2])
return res def check(self):
while True:
code=input('请输入你的验证码>>: ').strip()
if code.upper() == self.cache:
print('验证码输入正确')
self.t.cancel()
break obj=Code()
obj.check()