一、多线程

二、多线程编程之threading模块

2.1、使用threading进行多线程操作有两种方法：

三、多线程同步之Lock（互斥锁）

四、多线程同步之Semaphore（信号量）

五、多线程同步之Condition

六、多线程同步之Event

七、线程优先级队列（queue）

八、多线程之线程池pool

九、总结

---

一、多线程

线程（Thread）也称轻量级进程，是操作系统能够运行调度的最小单位，被包含在进程中，是进程中的实际运作单位。

线程自身不拥有系统资源，只拥有一些在运行中必不可少的资源，但可与同属一个进程的其他线程共享所拥有的全部资源

一个线程可以创建和撤销另一个线程，同一进程中的多个线程之间可以并发执行

• 就绪状态指线程具备运行的所有状态，逻辑上可以运行，在等待处理机
• 运行状态指线程占有处理机正在运行

• 阻塞状态指线程在等待一个事件，逻辑上不可执行

尽管GIL（全局锁 ）限制了CPython多线程在CPU密集型任务中的并行性，但Python的多线程在I/O密集型任务中依然能够发挥多核CPU的优势，通过在I/O等待期间执行其他任务来提升程序的运行效率。

实例1：计算密集型任务-多进程！！多进程！！多进程！！

 from multiprocessing import Process
 import os,time
 ​
 # 计算密集型任务
 def work():
     res = 0
     for i in range(100000000):
         res *= i
 ​
 if __name__ == '__main__':
     l = []
     print("本机为",os.cpu_count(),"核 CPU")
     start = time.time()
     for i in range(4):
         p = Process(target=work)    # 多进程
         l.append(p)
         p.start()
     for p in l:
         p.join()
     stop = time.time()
     print("计算密集型任务，多进程耗时 %s" % (stop - start))
     
 '''
 本机为 8 核 CPU
 计算密集型任务，多进程耗时 5.117187976837158
 '''

实例1：计算密集型任务-多线程！！多线程！！多线程！！

 import os,time
 from threading import Thread
 ​
 # 计算密集型任务
 def work():
     res = 0
     for i in range(100000000):
         res *= i
 ​
 if __name__ == '__main__':
     l = []
     print("本机为",os.cpu_count(),"核 CPU")
     start = time.time()
     for i in range(4):
         p = Thread(target=work)    # 多线程
         l.append(p)
         p.start()
     for p in l:
         p.join()
     stop = time.time()
     print("计算密集型任务，多线程耗时 %s" % (stop - start))
     
 '''
 本机为 8 核 CPU
 计算密集型任务，多线程耗时 14.287675857543945
 '''

实例2：I/O密集型任务-多进程！！多进程！！多进程！！

 from multiprocessing import Process
 import os,time
 ​
 # I/O密集型任务
 def work():
     time.sleep(2)
     print("===>",file=open("tmp.txt","w"))
 ​
 ​
 if __name__ == '__main__':
     l = []
     print("本机为", os.cpu_count(), "核 CPU")
     start = time.time()
     for i in range(400):
         p = Process(target=work)  # 多进程
         l.append(p)
         p.start()
     for p in l:
         p.join()
     stop = time.time()
     print("I/O密集型任务，多进程耗时 %s" % (stop - start))
 '''
 本机为 8 核 CPU
 I/O密集型任务，多进程耗时 11.03010869026184
 '''

实例2：I/O密集型任务-多线程！！多线程！！多线程！！

 import os,time
 from threading import Thread
 ​
 # I/O密集型任务
 def work():
     time.sleep(2)
     print("===>",file=open("tmp.txt","w"))
 ​
 ​
 if __name__ == '__main__':
     l = []
     print("本机为", os.cpu_count(), "核 CPU")
     start = time.time()
     for i in range(400):
         p = Thread(target=work)  # 多线程
         l.append(p)
         p.start()
     for p in l:
         p.join()
     stop = time.time()
     print("I/O密集型任务，多线程耗时 %s" % (stop - start))
 '''
 本机为 8 核 CPU
 I/O密集型任务，多线程耗时 2.0814177989959717
 '''

结论：在Python中，对于密集型任务，多进程占优势；对于I/O密集型任务，多线程占优势。

二、多线程编程之threading模块

Python提供多线程编程的模块有两个：thread和threading。thread模块提供低级别的基本功能来支持，提供简单的锁来确保同步（不推荐）。threading模块对_thread进行了封装，提供了更高级别，功能更强。

2.1、使用threading进行多线程操作有两种方法：

方法一：创建threading.Thread类的实例，调用其start()方法

 import time
 import threading
 ​
 def task_thread(counter):
     print(f'线程名称：{threading.current_thread().name} 参数：{counter} 开始时间：{time.strftime("%Y-%m-%d %H:%M:%S")}')
     num = counter
     while num:
         time.sleep(3)
         num -= 1
     print(f'线程名称：{threading.current_thread().name} 参数：{counter} 结束时间：{time.strftime("%Y-%m-%d %H:%M:%S")}')
 ​
 if __name__ == '__main__':
     print(f'主线程开始时间:{time.strftime("%Y-%m-%d %H:%M:%S")}')
 ​
     # 初始化三个线程，传递不同的参数
     t1 = threading.Thread(target=task_thread,args=(3,))
     t2 = threading.Thread(target=task_thread,args=(2,))
     t3 = threading.Thread(target=task_thread,args=(1,))
     # 开启三个线程
     t1.start();t2.start();t3.start()
     # 等待运行结束
     t1.join();t2.join();t3.join()
 ​
     print(f'主线程结束时间:{time.strftime("%Y-%m-%d %H:%M:%S")}')
 '''
 程序实例化了三个Thread类的实例，并任务函数传递不同的参数，使他们运行不同的时间后结束，start()方法开启线程，join()方法阻塞主线程，等待当前线程运行结束。
 '''

方法二：继承Thread类，在子类中重写run()和init()方法*（了解---）

 import time
 import threading
 ​
 class MyThread(threading.Thread):
     def __init__(self,counter):
         super().__init__()
         self.counter = counter
 ​
     def run(self):
         print(
             f'线程名称：{threading.current_thread().name} 参数：{self.counter} 开始时间：{time.strftime("%Y-%m-%d %H:%M:%S")}')
         counter = self.counter
         while counter:
             time.sleep(3)
             counter -= 1
         print(
             f'线程名称：{threading.current_thread().name} 参数：{self.counter} 结束时间：{time.strftime("%Y-%m-%d %H:%M:%S")}')
 if __name__ == '__main__':
     print(f'主线程开始时间:{time.strftime("%Y-%m-%d %H:%M:%S")}')
 ​
     # 初始化三个线程，传递不同的参数
     t1 = MyThread(3)
     t2 = MyThread(2)
     t3 = MyThread(1)
     # 开启三个线程
     t1.start();t2.start();t3.start()
     # 等待运行结束
     t1.join();t2.join();t3.join()
 ​
     print(f'主线程结束时间:{time.strftime("%Y-%m-%d %H:%M:%S")}')

如果继承Thread类，想要调用外部函数：

 import time
 import threading
 ​
 ​
 def task_thread(counter):
     print(
         f'线程名称：{threading.current_thread().name} 参数：{counter} 开始时间：{time.strftime("%Y-%m-%d %H:%M:%S")}')
     num = counter
     while num:
         time.sleep(3)
         num -= 1
     print(
         f'线程名称：{threading.current_thread().name} 参数：{counter} 结束时间：{time.strftime("%Y-%m-%d %H:%M:%S")}')
 ​
 ​
 class MyThread(threading.Thread):
     def __init__(self,target,args):
         super().__init__()
         self.args = args
         self.target = target
 ​
     def run(self):
         self.target(*self.args)
 ​
 if __name__ == '__main__':
     print(f'主线程开始时间:{time.strftime("%Y-%m-%d %H:%M:%S")}')
 ​
     # 初始化三个线程，传递不同的参数
     t1 = MyThread(target=task_thread,args=(3,))
     t2 = MyThread(target=task_thread,args=(2,))
     t3 = MyThread(target=task_thread,args=(1,))
     # 开启三个线程
     t1.start();t2.start();t3.start()
     # 等待运行结束
     t1.join();t2.join();t3.join()
 ​
     print(f'主线程结束时间:{time.strftime("%Y-%m-%d %H:%M:%S")}')

三、多线程同步之Lock（互斥锁）

如果多个线程共同对某个数据修改，则可能出现不可预料的结果，这个时候就需要使用互斥锁来进行同步。例如：在三个线程对共同变量num进行100万次加减操作后，其num的结果不为0

不加锁的意外情况：

 import time,threading
 ​
 num = 0
 ​
 def task_thread(n):
     global  num
     for i in range(1000000):
         num = num + n
         num = num - n
 ​
 t1 = threading.Thread(target=task_thread,args=(6,))
 t2 = threading.Thread(target=task_thread,args=(17,))
 t3 = threading.Thread(target=task_thread,args=(11,))
 t1.start();t2.start();t3.start()
 t1.join();t2.join();t3.join()
 print(num)
 '''
 6
 '''

使用互斥锁对多个线程进行同步，限制当一个线程正在访问数据时，其他只能等待，直到前一线程释放锁。

使用threading.Thread对象的Lock和Rlock可以实现简单的线程同步，都有acquire和release方法。

 # 加互斥锁后运行结果始终一致
 import time,threading
 ​
 num = 0
 lock = threading.Lock()
 def task_thread(n):
     global num
     # 获取锁，用于线程同步
     lock.acquire()
     for i in range(1000000):
         num = num + n
         num = num - n
     # 释放锁，开启下一个线程
     lock.release()
 ​
 ​
 t1 = threading.Thread(target=task_thread,args=(6,))
 t2 = threading.Thread(target=task_thread,args=(17,))
 t3 = threading.Thread(target=task_thread,args=(11,))
 t1.start();t2.start();t3.start()
 t1.join();t2.join();t3.join()
 print(num)

四、多线程同步之Semaphore（信号量）

互斥锁是只允许一个线程访问共享数据，而信号量是同时运行一定数量的线程访问共享数据，比如银行柜台有5个窗口，运行同时有5个人办理业务，后面的人只能等待其完成。

 # 使用信号量控制并发
 import threading
 import time
 ​
 # 银行柜台窗口数量
 NUM_WINDOWS = 5
 ​
 # 用于控制窗口访问的信号量
 semaphore = threading.Semaphore(NUM_WINDOWS)
 ​
 # 客户办理业务的函数
 def customer(name, service_time):
     # 尝试获取信号量
     semaphore.acquire()
     print(f"{time.ctime()}: {name} 开始办理业务")
     time.sleep(service_time)  # 模拟办理业务的时间
     print(f"{time.ctime()}: {name} 办理业务完成")
     semaphore.release()  # 释放信号量
 ​
 # 创建客户线程列表
 customers = []
 for i in range(12):
     name = f"客户{i+1}"
     service_time = 3  # 假设每个客户办理业务需要1秒时间
     thread = threading.Thread(target=customer, args=(name, service_time))
     customers.append(thread)
 ​
 # 启动所有客户线程
 for customer in customers:
     customer.start()
 ​
 # 等待所有客户完成业务
 for customer in customers:
     customer.join()
 ​
 print("所有客户都办理完业务了。")

上述代码实现了同一时刻只有5个线程获得资源运行

五、多线程同步之Condition

条件对象Condition能让一个线程A停下来，等待其他线程B，线程B满足了某个条件后通知线程A继续运行。步骤：

线程首先获取一个条件变量锁，如果条件不足，则该线程等待（wait）并释放条件变量锁；如果条件满足，就继续执行线程，执行完成后可以通知（notify）其他状态为wait的线程执行。其他处于wait状态的线程接到通知后会重新判断条件来确定是否继续执行

 import threading
 ​
 class Boy(threading.Thread):
     def __init__(self,cond,name):
         super(Boy,self).__init__()
         self.cond = cond
         self.name = name
 ​
     def run(self):
         self.cond.acquire()
         print(self.name + ":嫁给我吧！？")
         self.cond.notify()  # 唤醒一个挂起的线程，让hanmeimei表态
         self.cond.wait()    # 释放内部所占用的锁，同时线程被挂起，直至接收到通知被唤醒或超时，等待heimeimei回答
         print(self.name + ": 我单膝下跪，送上戒指！")
         self.cond.notify()
         self.cond.wait()
         print(self.name + ": lI太太，你的选择太明智了。")
         self.cond.release()
 class Girl(threading.Thread):
     def __init__(self,cond,name):
         super(Girl,self).__init__()
         self.cond = cond
         self.name = name
 ​
     def run(self):
         self.cond.acquire()
         self.cond.wait()    # 等待Lilei求婚
         print(self.name + ": 没有情调，不够浪漫，不答应")
         self.cond.notify()
         self.cond.wait()
         print(self.name + ": 好吧，答应你了")
         self.cond.notify()
         self.cond.release()
 ​
 cond = threading.Condition()
 boy = Boy(cond,"LiLei")
 girl = Girl(cond,"HanMeiMei")
 girl.start()
 boy.start()

六、多线程同步之Event

事件用于线程之间的通信。一个线程发出一个信号，其他一个或多个线程等待，调用Event对象的wait方法，线程则会阻塞等待，直到别的线程set之后才会被唤醒。与上述类似

 import threading
 import time
 ​
 ​
 class Boy(threading.Thread):
     def __init__(self,cond,name):
         super(Boy,self).__init__()
         self.cond = cond
         self.name = name
 ​
     def run(self):
         print(self.name + ":嫁给我吧！？")
         self.cond.set()  # 唤醒一个挂起的线程，让hanmeimei表态
         time.sleep(0.5)
         self.cond.wait()    # 释放内部所占用的锁，同时线程被挂起，直至接收到通知被唤醒或超时，等待heimeimei回答
         print(self.name + ": 我单膝下跪，送上戒指！")
         self.cond.set()
         time.sleep(0.5)
         self.cond.wait()
         self.cond.clear()
         print(self.name + ": lI太太，你的选择太明智了。")
 class Girl(threading.Thread):
     def __init__(self,cond,name):
         super(Girl,self).__init__()
         self.cond = cond
         self.name = name
 ​
     def run(self):
         self.cond.wait()    # 等待Lilei求婚
         self.cond.clear()
         print(self.name + ": 没有情调，不够浪漫，不答应")
         self.cond.set()
         time.sleep(0.5)
         self.cond.wait()
         print(self.name + ": 好吧，答应你了")
         self.cond.set()
 ​
 cond = threading.Event()
 boy = Boy(cond,"LiLei")
 girl = Girl(cond,"HanMeiMei")
 girl.start()
 boy.start()

七、线程优先级队列（queue）

Python的queue模块中提供了同步的、线程安全的队列类，包括先进先出队列Queue、后进先出队列LifoQueue和优先级队列PriorityQueue。这些队列都实现了锁原语，可以直接使用来实现线程之间的同步。

 '''
 有一小冰箱用来存放冷饮，假如只能放5瓶冷饮，A不停地放冷饮，B不停的取冷饮，A和B的放取速度不一致，如何保持同步呢？
 '''
 import threading,time
 import queue
 ​
 # 先进先出
 q = queue.Queue(maxsize=5)
 # q = LifoQuere(maxsize=3)
 # q = PriorityQueue(maxsize=3)
 ​
 def ProducerA():
     count = 1
     while True:
         q.put(f"冷饮 {count}")
         print(f"{time.strftime('%H:%M:%S')} A 放入：[冷饮 {count}]")
         count += 1
         time.sleep(2)
 ​
 def ConsumerB():
     while True:
         print(f"{time.strftime('%H:%M:%S')} B 取出：{q.get()}")
         time.sleep(5)
 ​
 p =  threading.Thread(target=ProducerA)
 c = threading.Thread(target=ConsumerB)
 p.start()
 c.start()

八、多线程之线程池pool

将 任务添加到线程池中，线程池会自动指定一个空闲的线程去执行任务，当超过线程池的最大线程数时，任务需要等待有新的空闲线程后才会被执行。

使用threading模块及queue模块定制线程池，可以使用multiprocessing。

• from multiprocessing import Pool导入的是进程池

• from multiprocessing.dummy import Pool导入的是线程池

 '''
 模拟一个耗时2秒的任务，比较其顺序执行5次和线程池（并发数为5）执行的耗时。
 '''
 from multiprocessing.dummy import Pool as ThreadPool
 import time
 ​
 def fun(n):
     time.sleep(2)
 ​
 start = time.time()
 for i in range(5):
     fun(i)
 print("单线程顺序执行耗时：",time.time() - start)
 ​
 start2 = time.time()
 # 开8个worker，没有参数时默认是cpu的核心数
 pool = ThreadPool(processes=5)
 # 在线程中执行urllib2.urlopen(url)并返回执行结果
 results2 = pool.map(fun,range(5))
 pool.close()
 pool.join()
 print("线程池（5）并发执行耗时：",time.time() - start2)
 '''
 单线程顺序执行耗时： 10.041245937347412
 线程池（5）并发执行耗时： 2.0453202724456787
 '''

九、总结

• Python多线程适合用在I/O密集型任务中。
• 对于I/O密集型任务来说，较少时间用在CPU计算上，较多时间用在I/O上，如文件读写、web请求、数据库请求等

• 对于计算密集型任务，应该使用多进程