一 python与线程
1.全局解释器锁GIL（用一下threading模块之后再来看~~）
Python代码的执行由Python虚拟机(也叫解释器主循环)来控制。Python在设计之初就考虑到要在主循环中，同时只有一个线程在执行。虽然 Python 解释器中可以“运行”多个线程，但在任意时刻只有一个线程在解释器中运行。
对Python虚拟机的访问由全局解释器锁(GIL)来控制，正是这个锁能保证同一时刻只有一个线程在运行。
在多线程环境中，Python 虚拟机按以下方式执行：
a、设置 GIL；
b、切换到一个线程去运行；
c、运行指定数量的字节码指令或者线程主动让出控制(可以调用 time.sleep(0))；
d、把线程设置为睡眠状态；
e、解锁 GIL；
d、再次重复以上所有步骤。
在调用外部代码(如 C/C++扩展函数)的时候，GIL将会被锁定，直到这个函数结束为止(由于在这期间没有Python的字节码被运行，所以不会做线程切换)编写扩展的程序员可以主动解锁GIL。
2.python线程模块的选择
Python提供了几个用于多线程编程的模块，包括thread、threading和Queue等。
thread和threading模块允许程序员创建和管理线程。
thread模块提供了基本的线程和锁的支持；
threading提供了更高级别、功能更强的线程管理的功能。
Queue模块允许用户创建一个可以用于多个线程之间共享数据的队列数据结构。
避免使用thread模块，因为更高级别的threading模块更为先进，对线程的支持更为完善，而且使用thread模块里的属性有可能会与threading出现冲突；其次低级别的thread模块的同步原语很少(实际上只有一个)，而threading模块则有很多；再者，thread模块中当主线程结束时，所有的线程都会被强制结束掉，没有警告也不会有正常的清除工作，至少threading模块能确保重要的子线程退出后进程才退出。
就像我们熟悉的time模块，它比其他模块更加接近底层，越是接近底层，用起来越麻烦，就像时间日期转换之类的就比较麻烦，但是后面我们会学到一个datetime模块，提供了更为简便的时间日期处理方法，它是建立在time模块的基础上来的。又如socket和socketserver（底层还是用的socket）等等，这里的threading就是thread的高级模块。
thread模块不支持守护线程，当主线程退出时，所有的子线程不论它们是否还在工作，都会被强行退出。而threading模块支持守护线程，守护线程一般是一个等待客户请求的服务器，如果没有客户提出请求它就在那等着，如果设定一个线程为守护线程，就表示这个线程是不重要的，在进程退出的时候，不用等待这个线程退出。
二 Threading模块
multiprocess模块的完全模仿了threading模块的接口，二者在使用层面，有很大的相似性，因而不再详细介绍
官方链接：https://docs.python.org/zh-cn/3.6/library/threading.html?highlight=threading#
我们先简单应用一下threading模块来看看并发效果 - 多线程简单实现：
import time
from threading import Thread
#多线程并发，是不是看着和多进程很类似
def func(n):
time.sleep(1)
print(n)
#并发效果，1秒打印出了所有的数字
for i in range(10):
t = Thread(target=func,args=(i,))
t.start()
1.线程创建
方式一：
from threading import Thread
import time
def sayhi(name):
time.sleep(2)
print('%s say hello' %name)
if __name__ == '__main__':
t=Thread(target=sayhi,args=('太白',))
t.start()
print('主线程')
方式二：
import time
from threading import Thread
class Sayhi(Thread):
def __init__(self,name):
super().__init__()
self.name=name
def run(self):
time.sleep(2)
print('%s say hello' % self.name)
if __name__ == '__main__':
t = Sayhi('太白')
t.start()
print('主线程')
2.多线程与多进程
首先来看看pid(进程id)
from threading import Thread
from multiprocessing import Process
import os
def work():
print('hello',os.getpid())
if __name__ == '__main__':
#part1:在主进程下开启多个线程,每个线程都跟主进程的pid一样
t1=Thread(target=work)
t2=Thread(target=work)
t1.start()
t2.start()
print('主线程/主进程pid',os.getpid())
#part2:开多个进程,每个进程都有不同的pid
p1=Process(target=work)
p2=Process(target=work)
p1.start()
p2.start()
print('主线程/主进程pid',os.getpid())
那么哪些东西存在进程里，那些东西存在线程里呢？
进程：导入的模块、执行的python文件的文件所在位置、内置的函数、文件里面的这些代码、全局变量等等。
然后线程里面有自己的堆栈（类似于一个列表，后进先出）和寄存器，里面存着自己线程的变量，操作（add）等等，占用的空间很小。
进程与线程开启效率比较：
from threading import Thread
from multiprocessing import Process
import os
import time
def work():
print('hello')
if __name__ == '__main__':
s1 = time.time()
# 在主进程下开启线程
t = Thread(target=work)
t.start()
t.join()
t1 = time.time() - s1
print('进程的执行时间：', t1)
print('主线程/主进程')
'''
打印结果:
hello
进程的执行时间： 0.00041604042053222656
主线程/主进程
'''
s2 = time.time()
# 在主进程下开启子进程
t = Process(target=work)
t.start()
t.join()
t2 = time.time() - s2
print('线程的执行时间：', t2)
print('主线程/主进程')
'''
打印结果:
hello
线程的执行时间： 0.019865036010742188
主线程/主进程
'''
内存数据共享：
from threading import Thread
from multiprocessing import Process
def work():
global n # 修改全局变量的值
n = 0
if __name__ == '__main__':
n = 100
p = Process(target=work)
p.start()
p.join()
print('主', n) # 毫无疑问子进程p已经将自己的全局的n改成了0,但改的仅仅是它自己的,查看父进程的n仍然为100
n = 1
t = Thread(target=work)
t.start()
t.join() # 必须加join，因为主线程和子线程不一定谁快，一般都是主线程快一些，所有我们要等子线程执行完毕才能看出效果
print('主', n) # 查看结果为0,因为同一进程内的线程之间共享进程内的数据
# 通过一个global就实现了全局变量的使用，不需要进程的IPC通信方法
在这里我们简单总结一下：
进程是最小的内存分配单位
线程是操作系统调度的最小单位
线程被CPU执行了
进程内至少含有一个线程
进程中可以开启多个线程
- 开启一个线程所需要的时间要远小于开启一个进程
- 多个线程内部有自己的数据栈，数据不共享
- 全局变量在多个线程之间是共享的
3.多线程实现socket
tcp_server.py：
import threading
import socket
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
s.bind(('127.0.0.1', 8080))
s.listen(5)
def action(conn):
while True:
data = conn.recv(1024)
print(data)
msg = input('服务端输入:') # 在多线程里面可以使用input输入内容，那么就可以实现客户端和服务端的聊天了，多进程不能输入
conn.send(bytes(msg, encoding='utf-8'))
if __name__ == '__main__':
while True:
conn, addr = s.accept()
p = threading.Thread(target=action, args=(conn,))
p.start()
tcp_client.py
import socket
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
s.connect(('127.0.0.1', 8080))
while True:
msg = input('>>: ').strip()
if not msg: continue
s.send(msg.encode('utf-8'))
data = s.recv(1024)
print(data)
在socket通信里面是有大量的I/O、recv、accept等等，我们使用多线程效率更高，因为开销小
4.Thread类的其他方法
Thread实例对象的方法：
isAlive(): 返回线程是否活动的。
getName(): 返回线程名。
setName(): 设置线程名。
threading模块提供的一些方法：
threading.currentThread(): 返回当前的线程变量。
threading.enumerate(): 返回一个包含正在运行的线程的list。正在运行指线程启动后、结束前，不包括启动前和终止后的线程。
threading.activeCount(): 返回正在运行的线程数量，与len(threading.enumerate())有相同的结果
代码示例：
from threading import Thread
import threading
def work():
import time
time.sleep(3)
print(threading.current_thread().getName())
if __name__ == '__main__':
# 在主进程下开启线程
t = Thread(target=work)
t.start()
print(threading.current_thread()) # 主线程对象
print(threading.current_thread().getName()) # 主线程名称
print(threading.current_thread().ident) # 主线程ID
print(threading.get_ident()) # 主线程ID
print(threading.enumerate()) # 连同主线程在内有两个运行的线程
print(threading.active_count())
print('主线程/主进程')
'''
打印结果:
<_MainThread(MainThread, started 140734757582272)>
MainThread
140734757582272
140734757582272
[<_MainThread(MainThread, started 140734757582272)>, <Thread(Thread-1, started 123145308700672)>]
2
主线程/主进程
Thread-1
'''
join方法：
from threading import Thread
import time
def sayhi(name):
time.sleep(2)
print('%s say hello' % name)
if __name__ == '__main__':
t = Thread(target=sayhi, args=('太白',))
t2 = Thread(target=sayhi, args=('alex',))
t.start()
t2.start()
t.join() # 因为这个线程用了join方法，主线程等待子线程的运行结束
print('主线程')
print(t.is_alive()) # 所以t这个线程肯定是执行结束了，结果为False
print(t2.is_alive()) # 有可能是True，有可能是False，看子线程和主线程谁执行的快
'''
alex say hello
太白 say hello
主线程
False
False
'''
5.守护线程
无论是进程还是线程，都遵循：守护xx会等待主xx运行完毕后被销毁。需要强调的是：运行完毕并非终止运行。
1.对主进程来说，运行完毕指的是主进程代码运行完毕
2.对主线程来说，运行完毕指的是主线程所在的进程内所有非守护线程统统运行完毕，主线程才算运行完毕
主进程在其代码结束后就已经算运行完毕了（守护进程在此时就被回收）,然后主进程会一直等非守护的子进程都运行完毕后回收子进程的资源(否则会产生僵尸进程)，才会结束；
主线程在其他非守护线程运行完毕后才算运行完毕（守护线程在此时就被回收）。因为主线程的结束意味着进程的结束，进程整体的资源都将被回收，而进程必须保证非守护线程都运行完毕后才能结束，因为进程执行结束是要回收资源的，所有必须确保你里面的非守护子线程全部执行完毕。
守护线程示例1：
from threading import Thread
import time
def sayhi(name):
time.sleep(2)
print('%s say hello' %name)
if __name__ == '__main__':
t=Thread(target=sayhi,args=('taibai',))
t.setDaemon(True) #必须在t.start()之前设置
t.start()
print('主线程')
print(t.is_alive())
'''
主线程
True
'''
守护线程示例2：
from threading import Thread
from multiprocessing import Process
import time
def func1():
while True:
print(666)
time.sleep(0.5)
def func2():
print('hello')
time.sleep(3)
if __name__ == '__main__':
t = Thread(target=func1,)
t.daemon = True #主线程结束，守护线程随之结束
# t.setDaemon(True) #两种方式，和上面设置守护线程是一样的
t.start()
t2 = Thread(target=func2,) # 这个子线程要执行3秒，主线程的代码虽然执行完了，但是一直等着子线程的任务执行完毕，主线程才算完毕，因为通过结果你会发现我主线程虽然代码执行完毕了，
# 但是主线程的的守护线程t1还在执行，说明什么，说明我的主线程还没有完毕，只不过是代码执行完了，一直等着子线程t2执行完毕，我主线程的守护线程才停止，说明子线程执行完毕之后，我的主线程才执行完毕
t2.start()
print('主线程代码执行完啦！')
p = Process(target=func1, )
p.daemon = True
p.start()
p2 = Process(target=func2, )
p2.start()
time.sleep(1) # 让主进程等1秒，为了能看到func1的打印效果
print('主进程代码执行完啦！') # 通过结果你会发现，如果主进程的代码运行完毕了，那么主进程就结束了，因为主进程的守护进程p随着主进程的代码结束而结束了，守护进程被回收了，这和线程是不一样的，主线程的代码完了并不代表主线程运行完毕了，需要等着所有其他的非守护的子线程执行完毕才算完毕
三 锁
1.GIL锁(Global Interpreter Lock)
首先，一些语言（java、c++、c）是支持同一个进程中的多个线程是可以应用多核CPU的，也就是我们会听到的现在4核8核这种多核CPU技术的牛逼之处。那么我们之前说过应用多进程的时候如果有共享数据是不是会出现数据不安全的问题啊，就是多个进程同时一个文件中去抢这个数据，大家都把这个数据改了，但是还没来得及去更新到原来的文件中，就被其他进程也计算了，导致数据不安全的问题啊，所以我们是不是通过加锁可以解决啊，多线程大家想一下是不是一样的，并发执行就是有这个问题。但是python最早期的时候对于多线程也加锁，但是python比较极端的（在当时电脑cpu确实只有1核）加了一个GIL全局解释锁，是解释器级别的，锁的是整个线程，而不是线程里面的某些数据操作，每次只能有一个线程使用cpu，也就说多线程用不了多核，但是他不是python语言的问题，是CPython解释器的特性，如果用Jpython解释器是没有这个问题的，Cpython是默认的，因为速度快，Jpython是java开发的，在Cpython里面就是没办法用多核，这是python的弊病，历史问题，虽然众多python团队的大神在致力于改变这个情况，但是暂没有解决。（这和解释型语言（python，php）和编译型语言有关系吗？？？待定！，编译型语言一般在编译的过程中就帮你分配好了，解释型要边解释边执行，所以为了防止出现数据不安全的情况加上了这个锁，这是所有解释型语言的弊端？？）
但是有了这个锁我们就不能并发了吗？当我们的程序是偏计算的，也就是cpu占用率很高的程序（cpu一直在计算），就不行了，但是如果你的程序是I/O型的（一般你的程序都是这个）（input、访问网址网络延迟、打开/关闭文件读写），在什么情况下用的到高并发呢（金融计算会用到，人工智能（阿尔法狗），但是一般的业务场景用不到，爬网页，多用户网站、聊天软件、处理文件），I/O型的操作很少占用CPU，那么多线程还是可以并发的，因为cpu只是快速的调度线程，而线程里面并没有什么计算，就像一堆的网络请求，我cpu非常快速的一个一个的将你的多线程调度出去，你的线程就去执行I/O操作了，
详细的GIL锁介绍：链接：https://www.cnblogs.com/clschao/articles/9705317.html
2.同步锁
三个需要注意的点：
线程抢的是GIL锁，GIL锁相当于执行权限，拿到执行权限后才能拿到
互斥锁Lock，其他线程也可以抢到GIL，但如果发现Lock仍然没有被释放则阻塞，即便是拿到执行权限GIL也要立刻交出来join是等待所有，即整体串行，而锁只是锁住修改共享数据的部分，即部分串行，要想保证数据安全的根本原理在于让并发变成串行，join与互斥锁都可以实现，毫无疑问，互斥锁的部分串行效率要更高一定要看本小节最后的GIL与互斥锁的经典分析
GIL VS Lock
机智的同学可能会问到这个问题，就是既然你之前说过了，Python已经有一个GIL来保证同一时间只能有一个线程来执行了，为什么这里还需要lock?
首先我们需要达成共识：锁的目的是为了保护共享的数据，同一时间只能有一个线程来修改共享的数据
然后，我们可以得出结论：保护不同的数据就应该加不同的锁。
最后，问题就很明朗了，GIL 与Lock是两把锁，保护的数据不一样，前者是解释器级别的（当然保护的就是解释器级别的数据，比如垃圾回收的数据），后者是保护用户自己开发的应用程序的数据，很明显GIL不负责这件事，只能用户自定义加锁处理，即Lock
过程分析：所有线程抢的是GIL锁，或者说所有线程抢的是执行权限
线程1抢到GIL锁，拿到执行权限，开始执行，然后加了一把Lock，还没有执行完毕，即线程1还未释放Lock，有可能线程2抢到GIL锁，开始执行，执行过程中发现Lock还没有被线程1释放，于是线程2进入阻塞，被夺走执行权限，有可能线程1拿到GIL，然后正常执行到释放Lock。。。这就导致了串行运行的效果
既然是串行，那我们执行
t1.start()
t1.join
t2.start()
t2.join()
这也是串行执行啊，为何还要加Lock呢，需知join是等待t1所有的代码执行完，相当于锁住了t1的所有代码，而Lock只是锁住一部分操作共享数据的代码。
详解：
因为Python解释器帮你自动定期进行内存回收，你可以理解为python解释器里有一个独立的线程，每过一段时间它起wake up做一次全局轮询看看哪些内存数据是可以被清空的，此时你自己的程序 里的线程和 py解释器自己的线程是并发运行的，假设你的线程删除了一个变量，py解释器的垃圾回收线程在清空这个变量的过程中的clearing时刻，可能一个其它线程正好又重新给这个还没来及得清空的内存空间赋值了，结果就有可能新赋值的数据被删除了，为了解决类似的问题，python解释器简单粗暴的加了锁，即当一个线程运行时，其它人都不能动，这样就解决了上述的问题， 这可以说是Python早期版本的遗留问题。
看一段代码：
解释为什么要加锁，如果下面代码中work函数里面的那个time.sleep(0.005)，我的电脑用的这个时间片段，每次运行都呈现不同的结果，我们可以改改时间试一下。(需要仔细研究下面代码)
from threading import Thread,Lock
import os,time
def work():
global n
# lock.acquire() #加锁
temp=n
time.sleep(0.1) #一会将下面循环的数据加大并且这里的时间改的更小试试
n=temp-1
# time.sleep(0.02)
# n = n - 1
'''如果这样写的话看不出来效果，因为这样写就相当于直接将n的指向改了，就好比从10，经过1次减1之后，n就直接指向了9，速度太快，看不出效果，那么我们怎么办呢，找一个中间变量来接收n，然后对这个中间变量进行修改，然后再赋值给n，多一个给n赋值的过程，那么在这个过程中间，我们加上一点阻塞时间，来看效果，就像读文件修改数据之后再写回文件的过程。那么这个程序就会出现结果为9的情况，首先一个进程的全局变量对于所有线程是共享的，由于我们在程序给中间变量赋值，然后给n再次赋值的过程中我们加了一些I/O时间，遇到I/O就切换，那么每个线程都拿到了10，并对10减1了，然后大家都得到了9，然后再赋值给n，所有n等于了9'''
# lock.release()
if __name__ == '__main__':
lock=Lock()
n=100
l=[]
# for i in range(10000): #如果这里变成了10000，你在运行一下看看结果
for i in range(100): #如果这里变成了10000，你在运行一下看看结果
p=Thread(target=work)
l.append(p)
p.start()
for p in l:
p.join()
print(n) #结果肯定为0，由原来的并发执行变成串行，牺牲了执行效率保证了数据安全
上面这个代码示例，如果循环次数变成了10000，在我的电脑上就会出现不同的结果，因为在线程切换的那个time.sleep的时间内，有些线程还没有被切换到，也就是有些线程还没有拿到n的值，所以计算结果就没准了。
锁通常被用来实现对共享资源的同步访问。为每一个共享资源创建一个Lock对象，当你需要访问该资源时，调用acquire方法来获取锁对象（如果其它线程已经获得了该锁，则当前线程需等待其被释放），待资源访问完后，再调用release方法释放锁：
import threading
R = threading.Lock()
R.acquire()
# R.acquire()如果这里还有一个acquire，你会发现，程序就阻塞在这里了，因为上面的锁已经被拿到了并且还没有释放的情况下，再去拿就阻塞住了
'''
对公共数据的操作
'''
R.release()
通过上面的代码示例，我们看到多个线程抢占资源的情况，可以通过加锁来解决，看代码 - 同步锁的引用：
from threading import Thread, Lock
import time
def work():
global n
lock.acquire() # 加锁
temp = n
time.sleep(0.1)
n = temp - 1
lock.release()
if __name__ == '__main__':
lock = Lock()
n = 100
l = []
for i in range(100):
p = Thread(target=work)
l.append(p)
p.start()
for p in l:
p.join()
print(n) # 结果肯定为0，由原来的并发执行变成串行，牺牲了执行效率保证了数据安全
GIL锁与互斥锁综合分析
分析：
#1. 100个线程去抢GIL锁，即抢执行权限
#2. 肯定有一个线程先抢到GIL（暂且称为线程1），然后开始执行，一旦执行就会拿到lock.acquire()
#3. 极有可能线程1还未运行完毕，就有另外一个线程2抢到GIL，然后开始运行，但线程2发现互斥锁lock还未被线程1释放，于是阻塞，被迫交出执行权限，即释放GIL
#4. 直到线程1重新抢到GIL，开始从上次暂停的位置继续执行，直到正常释放互斥锁lock，然后其他的线程再重复2 3 4的过程
互斥锁与join的区别(重点)
不加锁:并发执行,速度快,数据不安全
from threading import current_thread, Thread, Lock
import time
def task():
global n
print('%s is running' % current_thread().getName())
temp = n
time.sleep(0.5)
n = temp - 1
if __name__ == '__main__':
n = 100
lock = Lock()
threads = []
start_time = time.time()
for i in range(100):
t = Thread(target=task)
threads.append(t)
t.start()
for t in threads:
t.join()
stop_time = time.time()
print('主:%s n:%s' % (stop_time - start_time, n))
'''
Thread-1 is running
Thread-2 is running
......
Thread-100 is running
主:0.5216062068939209 n:99
'''
不加锁:未加锁部分并发执行,加锁部分串行执行,速度慢,数据安全
# 不加锁:未加锁部分并发执行,加锁部分串行执行,速度慢,数据安全
from threading import current_thread, Thread, Lock
import time
def task():
# 未加锁的代码并发运行
time.sleep(3)
print('%s start to run' % current_thread().getName())
global n
# 加锁的代码串行运行
lock.acquire()
temp = n
time.sleep(0.5)
n = temp - 1
lock.release()
if __name__ == '__main__':
n = 100
lock = Lock()
threads = []
start_time = time.time()
for i in range(100):
t = Thread(target=task)
threads.append(t)
t.start()
for t in threads:
t.join()
stop_time = time.time()
print('主:%s n:%s' % (stop_time - start_time, n))
'''
Thread-1 is running
Thread-2 is running
......
Thread-100 is running
主:53.294203758239746 n:0
'''
有的同学可能有疑问:既然加锁会让运行变成串行,那么我在start之后立即使用join,就不用加锁了啊,也是串行的效果啊
没错，在start之后立刻使用jion,肯定会将100个任务的执行变成串行,毫无疑问,最终n的结果也肯定是0,是安全的,但问题是:start后立即join:任务内的所有代码都是串行执行的,而加锁,只是加锁的部分即修改共享数据的部分是串行的。单从保证数据安全方面,二者都可以实现,但很明显是加锁的效率更高.
from threading import current_thread,Thread,Lock
import os,time
def task():
time.sleep(3)
print('%s start to run' %current_thread().getName())
global n
temp=n
time.sleep(0.5)
n=temp-1
if __name__ == '__main__':
n=100
lock=Lock()
start_time=time.time()
for i in range(100):
t=Thread(target=task)
t.start()
t.join()
stop_time=time.time()
print('主:%s n:%s' %(stop_time-start_time,n))
'''
Thread-1 start to run
Thread-2 start to run
......
Thread-100 start to run
主:350.6937336921692 n:0 #耗时是多么的恐怖
'''
3.死锁与递归锁
进程也有 死锁 与 递归锁 ，在进程那里忘记说了，放到这里一切说了，进程的死锁和线程的是一样的，而且一般情况下进程之间是数据不共享的，不需要加锁，由于线程是对全局的数据共享的，所以对于全局的数据进行操作的时候，要加锁。
所谓死锁： 是指两个或两个以上的进程或线程在执行过程中，因争夺资源而造成的一种互相等待的现象，若无外力作用，它们都将无法推进下去。此时称系统处于死锁状态或系统产生了死锁，这些永远在互相等待的进程称为死锁进程。
如下就是死锁：
from threading import Lock as Lock
import time
mutexA=Lock()
mutexA.acquire()
mutexA.acquire()
print(123)
mutexA.release()
mutexA.release()
更难一些的死锁现象：
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(' 33[41m%s 拿到A锁>>> 33[0m' %self.name)
mutexB.acquire()
print(' 33[42m%s 拿到B锁>>> 33[0m' %self.name)
mutexB.release()
mutexA.release()
def func2(self):
mutexB.acquire()
print(' 33[43m%s 拿到B锁??? 33[0m' %self.name)
time.sleep(2)
#分析：当线程1执行完func1，然后执行到这里的时候，拿到了B锁，线程2执行func1的时候拿到了A锁，那么线程2还要继续执行func1里面的代码，再去拿B锁的时候，发现B锁被人拿了，那么就一直等着别人把B锁释放，那么就一直等着，等到线程1的sleep时间用完之后，线程1继续执行func2，需要拿A锁了，但是A锁被线程2拿着呢，还没有释放，因为他在等着B锁被释放，那么这俩人就尴尬了，你拿着我的老A，我拿着你的B，这就尴尬了，俩人就停在了原地
mutexA.acquire()
print(' 33[44m%s 拿到A锁??? 33[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锁>>>
然后就卡住，死锁了
'''
解决方法: 递归锁，在Python中为了支持在同一线程中多次请求同一资源，python提供了可重入锁RLock。
这个RLock内部维护着一个Lock和一个counter变量，counter记录了acquire的次数，从而使得资源可以被多次require。直到一个线程所有的acquire都被release，其他的线程才能获得资源。上面的例子如果使用RLock代替Lock，则不会发生死锁：
from threading import RLock as Lock
import time
mutexA=Lock()
mutexA.acquire()
mutexA.acquire()
print(123)
mutexA.release()
mutexA.release()
典型问题 - 科学家吃面: 和上面更难一些的死锁现象是一样的
import time
from threading import Thread,Lock
noodle_lock = Lock()
fork_lock = Lock()
def eat1(name):
noodle_lock.acquire()
print('%s 抢到了面条'%name)
fork_lock.acquire()
print('%s 抢到了叉子'%name)
print('%s 吃面'%name)
fork_lock.release()
noodle_lock.release()
def eat2(name):
fork_lock.acquire()
print('%s 抢到了叉子' % name)
time.sleep(1)
noodle_lock.acquire()
print('%s 抢到了面条' % name)
print('%s 吃面' % name)
noodle_lock.release()
fork_lock.release()
for name in ['taibai','egon','wulaoban']:
t1 = Thread(target=eat1,args=(name,))
t2 = Thread(target=eat2,args=(name,))
t1.start()
t2.start()
递归锁解决死锁问题：
import time
from threading import Thread,RLock
fork_lock = noodle_lock = RLock()
def eat1(name):
noodle_lock.acquire()
print('%s 抢到了面条'%name)
fork_lock.acquire()
print('%s 抢到了叉子'%name)
print('%s 吃面'%name)
fork_lock.release()
noodle_lock.release()
def eat2(name):
fork_lock.acquire()
print('%s 抢到了叉子' % name)
time.sleep(1)
noodle_lock.acquire()
print('%s 抢到了面条' % name)
print('%s 吃面' % name)
noodle_lock.release()
fork_lock.release()
for name in ['taibai','wulaoban']:
t1 = Thread(target=eat1,args=(name,))
t1.start()
for name in ['alex','peiqi']:
t2 = Thread(target=eat2,args=(name,))
t2.start()
递归锁大致描述：当我们的程序中需要两把锁的时候，你就要注意，别出现死锁，最好就去用递归锁。
