自学python如何成为大佬(目录):https://blog.csdn.net/weixin_67859959/article/details/139049996?spm=1001.2014.3001.5501
我们已经知道进程之间不能直接共享信息，那么线程之间可以共享信息吗？我们通过一个例子来验证一下。定义一个全局变量g_num，分别创建2个子线程对g_num执行不同的操作，并输出操作后的结果。代码如下：
# -*- coding:utf-8 -*-
from threading import Thread # 导入线程
import time
def plus(): # 第一个线程函数
print('-------子线程1开始------')
global g_num # 定义全局变量
g_num += 50 # 全局变量值加50
print('g_num is %d'%g_num)
print('-------子线程1结束------')
def minus(): # 第二个线程函数
time.sleep(1) # 休眠1毫秒
print('-------子线程2开始------')
global g_num # 定义全局变量
g_num -= 50 # 全局变量值减50
print('g_num is %d'%g_num)
print('-------子线程2结束------')
g_num = 100 # 定义一个全局变量
if __name__ == '__main__':
print('-------主线程开始------')
print('g_num is %d'%g_num)
t1 = Thread(target=plus) # 实例化线程t1
t2 = Thread(target=minus) # 实例化线程t2
t1.start() # 开启线程t1
t2.start() # 开启线程t2
t1.join() # 等待t1线程结束
t2.join() # 等待t2线程结束
print('-------主线程结束------')
上述代码中，定义一个全局变量g_num，赋值为100，然后创建2个线程。一个线程将g_num增加50，一个线程将g_num减少50。如果g_num的最终结果为100，则说明线程之间可以共享数据。运行结果如图17所示。
图17 检测线程数据是否共享
从上面的例子可以得出，在一个进程内的所有线程共享全局变量，能够在不使用其他方式的前提下完成多线程之间的数据共享。
1 什么是互斥锁
由于线程可以对全局变量随意修改，这就可能造成多线程之间对全局变量的混乱操作。依然以房子为例，当房子内只有一个居住者时（单线程），他可以任意时刻使用任意一个房间，如厨房、卧室和卫生间等。但是，当这个房子有多个居住者时（多线程），他就不能在任意时刻使用某些房间，如卫生间，否则就会造成混乱。
如何解决这个问题呢？一个防止他人进入的简单方法，就是门上加一把锁。先到的人锁上门，后到的人就在门口排队，等锁打开再进去。如图18所示。
图18 互斥锁示意图
这就是“互斥锁”（Mutual exclusion，缩写 Mutex），防止多个线程同时读写某一块内存区域。互斥锁为资源引入一个状态：锁定和非锁定。某个线程要更改共享数据时，先将其锁定，此时资源的状态为“锁定”，其他线程不能更改；直到该线程释放资源，将资源的状态变成“非锁定”时，其他的线程才能再次锁定该资源。互斥锁保证了每次只有一个线程进行写入操作，从而保证了多线程情况下数据的正确性。
2 使用互斥锁
在threading模块中使用Lock类可以方便地处理锁定。Lock类有2个方法：acquire()锁定和release()释放锁。示例用法如下：
mutex = threading.Lock() # 创建锁
mutex.acquire([blocking]) # 锁定
mutex.release() # 释放锁
参数说明如下：
l acquire([blocking])：获取锁定，如果有必要，需要阻塞到锁定释放为止。如果提供blocking参数并将它设置为False，当无法获取锁定时将立即返回False；如果成功获取锁定则返回True。
l release()：释放一个锁定。当锁定处于未锁定状态时，或者从与原本调用acquire()方法的不同线程调用此方法，将出现错误。
实例06 使用互斥锁实现多人同时订购电影票
下面，通过一个示例学习一下如何使用互斥锁。这里使用多线程和互斥锁模拟实现多人同时订购电影票的功能，假设电影院某个场次只有100张电影票，10个用户同时抢购该电影票。每售出一张，显示一次剩余的电影票张数。代码如下：
from threading import Thread,Lock
import time
n=100 # 共100张票
def task():
global n
mutex.acquire() # 上锁
temp=n # 赋值给临时变量
time.sleep(0.1) # 休眠0.1秒
n=temp-1 # 数量减1
print('购买成功，剩余%d张电影票'%n)
mutex.release() # 释放锁
if __name__ == '__main__':
mutex=Lock() # 实例化Lock类
t_l=[] # 初始化一个列表
for i in range(10):
t=Thread(target=task) # 实例化线程类
t_l.append(t) # 将线程实例存入列表中
t.start() # 创建线程
for t in t_l:
t.join() # 等待子线程结束
上述代码中，创建了10个线程，全部执行task()函数。为解决资源竞争问题，使用mutex.acquire()函数实现资源锁定，第一个获取资源的线程锁定后，其他线程等待mutex.release()解锁。所以每次只有一个线程执行task()函数。运行结果如图19所示。
图19 模拟购票功能
注意：使用互斥锁时，要避免死锁。在多任务系统下，当一个或多个线程等待系统资源，而资源又被线程本身或其他线程占用时，就形成了死锁，如图20所示。
图20 死锁示意图
3 使用队列在线程间通信
我们知道multiprocessing模块的Queue队列可以实现进程间通信，同样在线程间，也可以使用Queue队列实现线程间通信。不同之处在于我们需要使用queue模块的Queue队列，而不是multiprocessing
模块的Queue队列，但Queue的使用方法相同。
使用Queue在线程间通信通常应用于生产者消费者模式。产生数据的模块称为生产者，而处理数据的模块称为消费者。在生产者与消费者之间的缓冲区称之为仓库。生产者负责往仓库运输商品，而消费者负责从仓库里取出商品，这就构成了生产者消费者模式。下面通过一个示例学习一下使用Queue在线程间通信。
实例07 使用队列模拟生产者消费者模式
定义一个生产者类Producer，定义一个消费者类Consumer。生成者生成5件产品，依次写入队列，而消费者依次从队列中取出产品，代码如下：
from queue import Queue
import random,threading,time
# 生产者类
class Producer(threading.Thread):
def __init__(self, name,queue):
threading.Thread.__init__(self, name=name)
self.data=queue
def run(self):
for i in range(5):
print("生成者%s将产品%d加入队列!" % (self.getName(), i))
self.data.put(i)
time.sleep(random.random())
print("生成者%s完成!" % self.getName())
# 消费者类
class Consumer(threading.Thread):
def __init__(self,name,queue):
threading.Thread.__init__(self,name=name)
self.data=queue
def run(self):
for i in range(5):
val = self.data.get()
print("消费者%s将产品%d从队列中取出!" % (self.getName(),val))
time.sleep(random.random())
print("消费者%s完成!" % self.getName())
if __name__ == '__main__':
print('-----主线程开始-----')
queue = Queue() # 实例化队列
producer = Producer('Producer',queue) # 实例化线程Producer，并传入队列作为参数
consumer = Consumer('Consumer',queue) # 实例化线程Consumer，并传入队列作为参数
producer.start() # 启动线程Producer
consumer.start() # 启动线程Consumer
producer.join() # 等待线程producer结束
consumer.join() # 等待线程consumer结束
print('-----主线程结束-----')
运行结果如图21所示。
图21 使用Queue在线程间通信
注意：由于程序中使用了random.random()函数生成0-1之间的随机数，所以读者的运行结果可能与图21不同。
