开启一个字处理软件进程，该进程肯定需要办不止一件事情，比如监听键盘输入，处理文字，定时自动将文字保存到硬盘，这三个任务操作的都是同一块数据，因而不能用多进程。只能在一个进程里并发地开启三个线程,如果是单线程，那就只能是，键盘输入时，不能处理文字和自动保存，自动保存时又不能输入和处理文字。

之前我们将的socket是不是通过多进程去实现过呀，如果有500个人同时和我聊天，那我是不是要起500进程啊，能行吗？不好，对不对，那么怎么办，我就可以开几个进程，然后每个进程里面开多个线程来处理多个请求和通信。再举例：我用qq是一个进程，然后我和一个人聊天的时候，是不是还可以去接收别人给我发的消息啊，这个是不是并行的啊，就类似我一个进程开了多个线程来帮我并发接收消息。

五、内存中的线程

多个线程共享同一个进程的地址空间中的资源，是对一台计算机上多个进程的模拟，有时也称线程为轻量级的进程。

而对一台计算机上多个进程，则共享物理内存、磁盘、打印机等其他物理资源。多线程的运行也多进程的运行类似，是cpu在多个线程之间的快速切换。

不同的进程之间是充满敌意的，彼此是抢占、竞争cpu的关系，如果迅雷会和QQ抢资源。而同一个进程是由一个程序员的程序创建，所以同一进程内的线程是合作关系，一个线程可以访问另外一个线程的内存地址，大家都是共享的，一个线程干死了另外一个线程的内存，那纯属程序员脑子有问题。

类似于进程，每个线程也有自己的堆栈，不同于进程，线程库无法利用时钟中断强制线程让出CPU，可以调用thread_yield运行线程自动放弃cpu，让另外一个线程运行。

线程通常是有益的，但是带来了不小程序设计难度，线程的问题是：

1. 父进程有多个线程，那么开启的子线程是否需要同样多的线程

2. 在同一个进程中，如果一个线程关闭了文件，而另外一个线程正准备往该文件内写内容呢？

因此，在多线程的代码中，需要更多的心思来设计程序的逻辑、保护程序的数据。

六、python与线程

1.全局解释器锁GIL

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模块

我们先简单应用下threading模块来看看效果：

importtimefrom threading importThread#多线程并发，是不是看着和多进程很类似

deffunc(n):

time.sleep(1)print(n)#并发效果，1秒打印出了所有的数字

for i in range(10):

t= Thread(target=func,args=(i,))

t.start()

多线程简单实现

1.线程的创建

from threading importThreadimporttimedefsayhi(name):

time.sleep(2)print('%s say hello' %name)if __name__ == '__main__':

t=Thread(target=sayhi,args=('太白',))

t.start()print('主线程')

线程创建方式一

importtimefrom threading importThreadclassSayhi(Thread):def __init__(self,name):

super().__init__()

self.name=namedefrun(self):

time.sleep(2)print('%s say hello' %self.name)if __name__ == '__main__':

t= Sayhi('太白')

t.start()print('主线程')

线程创建方式二

2.多线程与多进程

from threading importThreadfrom multiprocessing importProcessimportosdefwork():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 importThreadfrom multiprocessing importProcessimportosimporttimedefwork():print('hello')if __name__ == '__main__':

s1=time.time()#在主进程下开启线程

t=Thread(target=work)

t.start()

t.join()

t1= time.time() -s1print('进程的执行时间：',t1)print('主线程/主进程')'''打印结果:

hello

进程的执行时间： 0.0

主线程/主进程'''s2=time.time()#在主进程下开启子进程

t=Process(target=work)

t.start()

t.join()

t2= time.time() -s2print('线程的执行时间：', t2)print('主线程/主进程')'''打印结果:

hello

线程的执行时间： 0.5216977596282959

主线程/主进程'''

进程与线程开启效率比较

from threading importThreadfrom multiprocessing importProcessimportosdefwork():global n #修改全局变量的值

n=0if __name__ == '__main__':#n=100

#p=Process(target=work)

#p.start()

#p.join()

#print('主',n) #毫无疑问子进程p已经将自己的全局的n改成了0,但改的仅仅是它自己的,查看父进程的n仍然为100

n=1t=Thread(target=work)

t.start()

t.join()#必须加join，因为主线程和子线程不一定谁快，一般都是主线程快一些，所有我们要等子线程执行完毕才能看出效果

print('主',n) #查看结果为0,因为同一进程内的线程之间共享进程内的数据#通过一个global就实现了全局变量的使用，不需要进程的IPC通信方法

内存数据共享

在这里我们简单总结一下：

进程是最小的内存分配单位

线程是操作系统调度的最小党委

线程被CPU执行了

进程内至少含有一个线程

进程中可以开启多个线程

开启一个线程所需要的时间要远小于开启一个进程

多个线程内部有自己的数据栈，数据不共享

全局变量在多个线程之间是共享的

3.Thread类的其他方法

Thread实例对象的方法#isAlive(): 返回线程是否活动的。

#getName(): 返回线程名。

#setName(): 设置线程名。

threading模块提供的一些方法：#threading.currentThread(): 返回当前的线程变量。

#threading.enumerate(): 返回一个包含正在运行的线程的list。正在运行指线程启动后、结束前，不包括启动前和终止后的线程。

#threading.activeCount(): 返回正在运行的线程数量，与len(threading.enumerate())有相同的结果

其他方法

from threading importThreadimportthreadingfrom multiprocessing importProcessimportosdefwork():importtime

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

14104

14104

[<_mainthread started>, ]

2

主线程/主进程

Thread-1'''

from threading importThreadimporttimedefsayhi(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，看子线程和主线程谁执行的快

'''egon say hello

主线程

False'''

join方法

4.守护线程

无论是进程还是线程，都遵循：守护xx会等待主xx运行完毕后被销毁。需要强调的是：运行完毕并非终止运行

#1.对主进程来说，运行完毕指的是主进程代码运行完毕#2.对主线程来说，运行完毕指的是主线程所在的进程内所有非守护线程统统运行完毕，主线程才算运行完毕

详细解释如下：

#1 主进程在其代码结束后就已经算运行完毕了(守护进程在此时就被回收),然后主进程会一直等非守护的子进程都运行完毕后回收子进程的资源(否则会产生僵尸进程)，才会结束，#2 主线程在其他非守护线程运行完毕后才算运行完毕(守护线程在此时就被回收)。因为主线程的结束意味着进程的结束，进程整体的资源都将被回收，而进程必须保证非守护线程都运行完毕后才能结束，因为进程执行结束是要回收资源的，所有必须确保你里面的非守护子线程全部执行完毕。

from threading importThreadimporttimedefsayhi(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'''

守护线程示例1

from threading importThreadfrom multiprocessing importProcessimporttimedeffunc1():whileTrue:print(666)

time.sleep(0.5)deffunc2():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随着主进程的代码结束而结束了，守护进程被回收了，这和线程是不一样的，主线程的代码完了并不代表主线程运行完毕了，需要等着所有其他的非守护的子线程执行完毕才算完毕

守护线程示例2

八、锁

1.GIL锁

首先，一些语言(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操作了。

2.同步锁

三个需要注意的点：#1.线程抢的是GIL锁，GIL锁相当于执行权限，拿到执行权限后才能拿到互斥锁Lock，其他线程也可以抢到GIL，但如果发现Lock仍然没有被释放则阻塞，即便是拿到执行权限GIL也要立刻交出来

#2.join是等待所有，即整体串行，而锁只是锁住修改共享数据的部分，即部分串行，要想保证数据安全的根本原理在于让并发变成串行，join与互斥锁都可以实现，毫无疑问，互斥锁的部分串行效率要更高

#3. 一定要看本小节最后的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 importThread,Lockimportos,timedefwork():globaln#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=100l=[]#for i in range(10000): #如果这里变成了10000，你在运行一下看看结果

for i in range(100): #如果这里变成了10000，你在运行一下看看结果

p=Thread(target=work)

l.append(p)

p.start()for p inl:

p.join()print(n) #结果肯定为0，由原来的并发执行变成串行，牺牲了执行效率保证了数据安全

示例代码

上面这个代码示例，如果循环次数变成了10000，在我的电脑上就会出现不同的结果，因为在线程切换的那个time.sleep的时间内，有些线程还没有被切换到，也就是有些线程还没有拿到n的值，所以计算结果就没准了。

锁通常被用来实现对共享资源的同步访问。为每一个共享资源创建一个Lock对象，当你需要访问该资源时，调用acquire方法来获取锁对象(如果其它线程已经获得了该锁，则当前线程需等待其被释放)，待资源访问完后，再调用release方法释放锁：

importthreading

R=threading.Lock()

R.acquire()#

#R.acquire()如果这里还有一个acquire，你会发现，程序就阻塞在这里了，因为上面的锁已经被拿到了并且

还没有释放的情况下，再去拿就阻塞住了

'''对公共数据的操作'''R.release()

通过上面的代码，我们看到多个线程抢占资源的情况，可以通过加锁来解决，看代码：

from threading importThread,Lockimportos,timedefwork():globaln

lock.acquire()#加锁

temp=n

time.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 inl:

p.join()print(n) #结果肯定为0，由原来的并发执行变成串行，牺牲了执行效率保证了数据安全

同步锁的应用

图形解释

分析：#1.100个线程去抢GIL锁，即抢执行权限

#2. 肯定有一个线程先抢到GIL(暂且称为线程1)，然后开始执行，一旦执行就会拿到lock.acquire()

#3. 极有可能线程1还未运行完毕，就有另外一个线程2抢到GIL，然后开始运行，但线程2发现互斥锁lock还未被线程1释放，于是阻塞，被迫交出执行权限，即释放GIL

#4.直到线程1重新抢到GIL，开始从上次暂停的位置继续执行，直到正常释放互斥锁lock，然后其他的线程再重复2 3 4的过程

GIL锁与互斥锁综合分析

#不加锁:并发执行,速度快,数据不安全

from threading importcurrent_thread,Thread,Lockimportos,timedeftask():globalnprint('%s is running' %current_thread().getName())

temp=n

time.sleep(0.5)

n=temp-1

if __name__ == '__main__':

n=100lock=Lock()

threads=[]

start_time=time.time()for i in range(100):

t=Thread(target=task)

threads.append(t)

t.start()for t inthreads:

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 importcurrent_thread,Thread,Lockimportos,timedeftask():#未加锁的代码并发运行

time.sleep(3)print('%s start to run' %current_thread().getName())globaln#加锁的代码串行运行

lock.acquire()

temp=n

time.sleep(0.5)

n=temp-1lock.release()if __name__ == '__main__':

n=100lock=Lock()

threads=[]

start_time=time.time()for i in range(100):

t=Thread(target=task)

threads.append(t)

t.start()for t inthreads:

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 importcurrent_thread,Thread,Lockimportos,timedeftask():

time.sleep(3)print('%s start to run' %current_thread().getName())globaln

temp=n

time.sleep(0.5)

n=temp-1

if __name__ == '__main__':

n=100lock=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 #耗时是多么的恐怖'''

互斥锁与join的区别

3.死锁和递归锁

进程也有死锁与递归锁，在进程那里忘记说了，放到这里一切说了额，进程的死锁和线程的是一样的，而且一般情况下进程之间是数据不共享的，不需要加锁，由于线程是对全局的数据共享的，所以对于全局的数据进行操作的时候，要加锁。

所谓死锁： 是指两个或两个以上的进程或线程在执行过程中，因争夺资源而造成的一种互相等待的现象，若无外力作用，它们都将无法推进下去。此时称系统处于死锁状态或系统产生了死锁，这些永远在互相等待的进程称为死锁进程，如下就是死锁

from threading importLock as Lockimporttime

mutexA=Lock()

mutexA.acquire()

mutexA.acquire()print(123)

mutexA.release()

mutexA.release()

更难一些的死锁现象

from threading importThread,Lockimporttime

mutexA=Lock()

mutexB=Lock()classMyThread(Thread):defrun(self):

self.func1()

self.func2()deffunc1(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()deffunc2(self):

mutexB.acquire()print('\033[43m%s 拿到B锁???\033[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('\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锁>>>

然后就卡住，死锁了'''

解决方法，递归锁，在Python中为了支持在同一线程中多次请求同一资源，python提供了可重入锁RLock。

这个RLock内部维护着一个Lock和一个counter变量，counter记录了acquire的次数，从而使得资源可以被多次require。直到一个线程所有的acquire都被release，其他的线程才能获得资源。上面的例子如果使用RLock代替Lock，则不会发生死锁：

from threading importRLock as Lockimporttime

mutexA=Lock()

mutexA.acquire()

mutexA.acquire()print(123)

mutexA.release()

mutexA.release()

递归锁大致描述：当我们的程序中需要两把锁的时候，你就要注意，别出现死锁，最好就去用递归锁。

九、信号量

同进程的一样

Semaphore管理一个内置的计数器，

每当调用acquire()时内置计数器-1；

调用release() 时内置计数器+1；

计数器不能小于0；当计数器为0时，acquire()将阻塞线程直到其他线程调用release()。

实例：(同时只有5个线程可以获得semaphore,即可以限制最大连接数为5)：

from threading importThread,Semaphoreimportthreadingimporttime#def func():#if sm.acquire():#print (threading.currentThread().getName() + ' get semaphore')#time.sleep(2)#sm.release()

deffunc():

sm.acquire()print('%s get sm' %threading.current_thread().getName())

time.sleep(3)

sm.release()if __name__ == '__main__':

sm=Semaphore(5)for i in range(23):

t=Thread(target=func)

t.start()

示例代码

十、事件

同进程的一样

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

事件的基本方法：

event.isSet()：返回event的状态值；

event.wait()：如果 event.isSet()==False将阻塞线程；

event.set()： 设置event的状态值为True，所有阻塞池的线程激活进入就绪状态， 等待操作系统调度；

event.clear()：恢复event的状态值为False。

还记得我们进程那里的事件用的什么例子吗，是不是红绿灯啊，这次我们不讲红绿灯的例子了，换个新的！

例如，有多个工作线程尝试链接MySQL，我们想要在链接前确保MySQL服务正常才让那些工作线程去连接MySQL服务器，如果连接不成功，都会去尝试重新连接。那么我们就可以采用threading.Event机制来协调各个工作线程的连接操作

MySQL是啥呢？简单说一下：

mysql就是一个数据库，存数据用的东西，它就像一个文件夹，里面存着很多的excel表格，我们可以在表格

里面写数据，存数据。但是如果我们要使用数据库，我们必须先要去连接它，你和他建立了连接关系，你才能

操作它里面存放的数据。

我们先模拟一个场景：

首先起两个线程：

第一个线程的用处：连接数据库，那么我这个线程需要等待一个信号，告诉我我们之间的网络是可以连通的。

第二个线程的用处：检测与数据库之间的网络是否联通，并发送一个可联通或者不可联通的信号。

from threading importThread,Eventimportthreadingimporttime,randomdefconn_mysql():

count=1

while notevent.is_set():if count > 3:raise TimeoutError('链接超时') #自己发起错误

print('第%s次尝试链接' %(threading.current_thread().getName(), count))

event.wait(0.5) # count+=1

print('链接成功' %threading.current_thread().getName())defcheck_mysql():print('\033[45m[%s]正在检查mysql\033[0m' %threading.current_thread().getName())

t1= random.randint(0,3)print('>>>>',t1)

time.sleep(t1)

event.set()if __name__ == '__main__':

event=Event()

check= Thread(target=check_mysql)

conn1=Thread(target=conn_mysql)

conn2=Thread(target=conn_mysql)

check.start()

conn1.start()

conn2.start()

模拟连接的代码示例