python线程安全队列讲解

最新推荐文章于 2025-09-18 16:37:18 发布
原创 最新推荐文章于 2025-09-18 16:37:18 发布 · 4.2k 阅读 · 3 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#python #开发语言

本文介绍了Python中线程安全的Queue模块，包括FIFO和LIFO队列，以及队列的常用方法如qsize、empty、full、put和get。在多线程环境下，Queue无需额外加锁即可确保线程安全。进一步探讨了生产者与消费者模式，通过队列作为缓冲区实现两者之间的同步。案例中，生产者负责将URL放入队列，消费者则从队列中取出并处理链接，例如下载图片。

一、线程安全队列

python内置的线程安全队列模块叫queue

python的Queue模块中提供了同步的、线程安全的队列类

FIFO（先进先出）队列的Queue（常用）

LIFO（后进先出）lifoQueue

可以使用队列来实现线程间的同步。

二、队列的常用方法

函数描述
qsize()返回队列大小
empty()判断队列是否为空
full()判断队列是否满了
get()从队列中获取先插入的数据
put()将一个数据放到队列中
  • qsize()返回队列大小
 

from queue import Queue
# 指定队列当中最多可存放5个数据
queue = Queue(5)
for num in range(5):
# put（）将一个数据放到队列中
queue.put(num) # 队列中获取先插入的数据
print("当前队列的大小为：", queue.qsize())
-------------------------
当前队列的大小为： 5


  • empty()判断队列是否为空
  • full() 判断队列是否为满


 

from queue import Queue
# 指定队列当中最多可存放5个数据
queue = Queue(5)
for num in range(5):
# put（）将一个数据放到队列中
queue.put(num) # 队列中获取先插入的数据
# 判断队列是否为空
print(queue.empty())
print(queue.full())
----------------------
False
True


  • put() 将一个数据放到队列中
  •  
    get() 从队列中获取先插入的数据 
     
     


 

from queue import Queue
# 指定队列当中最多可存放5个数据
queue = Queue(5)
for num in range(5):
# put（）将一个数据放到队列中
queue.put(num) # 队列中获取先插入的数据
print("当前队列的大小为：", queue.qsize())
# get（）从队列中获取先插入的数据
for i in range(1,6):
print(queue.get(i))
-------------------------------------
当前队列的大小为： 5
0
1
2
3
4


个人博客推荐：白煮蛋的博客 
 

三、在多线程当中使用
 

Queue是线程安全的队列，在使用时无须加锁，可以再多线程当中直接使用
 

队列也是实现线程间同步的方式
 

 

from queue import Queue
import threading
import random
import time
def put_data(queue):
while True:
queue.put(random.randint(10,100))
time.sleep(1)
print(queue.qsize())
def get_data(queue):
while True:
print(f"已经获取到队列当中的--{queue.get()}--元素")
def main():
queue = Queue(10)
t1 = threading.Thread(target=put_data,args=(queue,))
t2 = threading.Thread(target=get_data,args=(queue,))
t1.start()
t2.start()
if __name__ == '__main__':
main()


四、生产者与消费者模式
 

产生数据的模块，就形象地称为生产者；而处理数据的模块，就称为消费者。
 

 
 
单单抽象出生产者和消费者，还够不上是生产者／消费者模式。该模式还需要有一个缓冲区处于生产者和消费者之间，作为一个中介。生产者把数据放入缓冲区，而消费者从缓冲区取出数据。
 

 

  •  
    缓冲区
     


 
 
如果制造数据的速度时快时慢，缓冲区的好处就体现出来了。当数据制造快的时候，消费者来不及处理，未处理的数据可以暂时存在缓冲区中。等生产者的制造速度慢下来，消费者再慢慢处理掉。
 

 

  • 队列==缓冲区


（一）生产者与消费者模式案例
 

 

import requests
from bs4 import BeautifulSoup
import os
from threading import Thread
from queue import Queue
headers = {"User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/107.0.0.0 Safari/537.36 Edg/107.0.1418.26"}
# 生产者类
class Page_Url(Thread):
# page_queue 生产者队列
# img_queue 消费者队列
def __init__(self,page_queue,img_queue):
super().__init__()
self.page_queue = page_queue
self.img_queue = img_queue
def run(self):
while True:
if self.page_queue.empty():
break
url = self.page_queue.get()
self.download_image(url)
def download_image(self,url):
resp = requests.get(url, headers=headers).text
# print(resp)
soup = BeautifulSoup(resp, "lxml")
image_list = soup.find_all("img", class_="ui image lazy")
for img in image_list:
title = img.get("title")
href = img.get("data-original")
self.img_queue.put((title,href))
# 消费者类
class Img_Url(Thread):
# page_queue 生产者队列
# img_queue 消费者队列
def __init__(self, page_queue, img_queue):
super().__init__()
self.page_queue = page_queue
self.img_queue = img_queue
def run(self):
while True:
data = self.img_queue.get()
title,href = data
try:
with open("./image/"+title+os.path.splitext(href)[-1],"wb") as f:
resp =requests.get(href).content
f.write(resp)
print(title,"保存成功！")
except OSError:
pass
# 判断两个队列是否全部清空
if self.page_queue.empty() and self.img_queue.empty():
break
def main():
# 创建两个队列
page_queue = Queue()
img_queue = Queue()
for num in range(1,6):
url = "https://www.fabiaoqing.com/biaoqing/lists/page/{}.html".format(num)
# 将前五页的url添加到生产者队列
page_queue.put(url)
t1 = Page_Url(page_queue,img_queue)
t1.start()
t2 = Img_Url(page_queue,img_queue)
t2.start()
if __name__ == '__main__':
main()


 

（二）步骤解析
 

1、主类main
 

（1）创建生产者与消费者队列
 

（2）将前5页的url添加到生产者队列
 

 

def main():
# 创建两个队列
page_queue = Queue()
img_queue = Queue()
for num in range(1,6):
url = "https://www.fabiaoqing.com/biaoqing/lists/page/{}.html".format(num)
# 将前五页的url添加到生产者队列
page_queue.put(url)
t1 = Page_Url(page_queue,img_queue)
t1.start()
t2 = Img_Url(page_queue,img_queue)
t2.start()


2、生产者类
 

（1）生产者队列while循环当中获取的前5页的链接，当队列为空，停止获取。
 

 

def run(self):
while True:
if self.page_queue.empty():
break
url = self.page_queue.get()
self.download_image(url)


（2）将获取的链接给到dowl_img
 

 

def download_image(self,url):
resp = requests.get(url, headers=headers).text
# print(resp)
soup = BeautifulSoup(resp, "lxml")
image_list = soup.find_all("img", class_="ui image lazy")
for img in image_list:
title = img.get("title")
href = img.get("data-original")


（3）将获取到的名称和链接添加到消费者队列
 

 

self.img_queue.put((title,href))


3、消费者类
 

（1）从队列当中获取图片名称和链接
 

 

def run(self):
while True:
data = self.img_queue.get()
title,href = data


（2）保存图片
 

 

try:
with open("./image/"+title+os.path.splitext(href)[-1],"wb") as f:
resp =requests.get(href).content
f.write(resp)
print(title,"保存成功！")
except OSError:
pass
# 判断两个队列是否全部清空
if self.page_queue.empty() and self.img_queue.empty():
break


好了， 以上是本文所有内容，希望对大家有所帮助，也希望大家对码农之家多多支持，你们的支持是我创作的动力！祝大家生活愉快！    

                

        

    

  



    



                



	

		

			

				
					
Python高效并发编程：实现一个线程安全的队列

				
			

			

				

					windowshht的博客
				

				

					09-03
					
					864
					
				

			

		

		

			
				
线程安全的队列是一种数据结构，允许多个线程安全地进行入队（enqueue）和出队（dequeue）操作。线程安全意味着在多个线程同时访问队列时，不会出现数据竞争或不一致的情况。线程安全的队列通常通过锁（Lock）或条件变量（Condition Variable）来实现同步。

			
		

	



                

            
              



	

		

			

				
					
实现线程安全的队列Queue（Python）

					
热门推荐

				
			

			

				

					HenryLei的博客
				

				

					08-18
					
					2万+
					
				

			

		

		

			
				
关于队列

    用于存放多个元素，是存放各种元素的“池”。


实现的基本功能

    获取当前队列元素数量-->往队列放入元素-->往队列取出元素。

注意

    队列可能有多个线程同时操作，因此需要保证线程安全，如下两种情况：



具体实现


# -*- encoding=utf-8 -*-


import time
import threa...

			
		

	



              


  
              

                


	

		

			

				
					
基础知识五、Python实现线程池之线程安全队列

				
			

			

				

					01-20
				

			

		

		

			
				
文章目录一、线程池组成二、线程安全队列的实现三、测试逻辑3.1、测试阻塞逻辑3.2、测试读写加锁逻辑
一、线程池组成
       一个完整的线程池由下面几部分组成，线程安全队列、任务对象、线程处理对象、线程池对象。其中一个线程安全的队列是实现线程池和任务队列的基础，本节我们通过threading包中的互斥量threading.Lock()和条件变量threading.Condition()来实现一个简单的、读取安全的线程队列。

                    原创文章 15获赞 0访问量 557
                                           

			
		

	





	

		

			

				
					
Python线程安全分析

					
最新发布

				
			

			

				

					编程开发知识分享
				

				

					09-18
					
					822
					
				

			

		

		

			
				
Python线程安全机制解析：在多线程编程中，线程安全是确保共享资源正确访问的关键。Python通过GIL（全局解释器锁）实现部分线程安全，但存在CPU密集型任务性能受限等问题。核心解决方案包括：1）使用互斥锁、可重入锁等同步原语；2）采用线程安全队列、不可变对象等数据结构；3）通过进程或异步编程规避GIL限制。最佳实践建议：最小化共享状态、控制锁粒度、优先使用线程安全数据结构，并根据任务类型（I/O密集型或CPU密集型）选择合适并发模型。

			
		

	



		

			
		



	

		

			

				
					
[Python标准库]Queue——线程安全的 FIFO 实现

				
			

			

				

					dapeng0802的专栏
				

				

					12-25
					
					1万+
					
				

			

		

		

			
				
[Python标准库]Queue——线程安全的 FIFO 实现
        作用：提供一个线程安全的 FIFO 实现。
        Python 版本：至少 1.4
        Queue 模块提供一个适用于多线程编程的先进先出（first-in,first-out，FIFO）数据结构，可以用来在生产者消费者线程之间安全地传递消息或其他数据。它会为调用者处理锁定，使用多个线程可以

			
		

	





	

		

			

				
					
Python实现线程安全队列

				
			

			

				

					weixin_34290390的博客
				

				

					02-28
					
					197
					
				

			

		

		

			
				
最近学习spark，我主要使用pyspark api进行编程。之前使用Python都是现学现用，用完就忘了也没有理解和记忆，因此这里把Python相关的知识也弥补和记录下来吧多线程任务队列在实际项目中非常有用，关键的地方要实现队列的多线程同步问题，也即保证队列的多线程安全例如：可以开多个消费者线程，每个线程上绑定一个队列，这样就实现了多个消费者同时处理不同队列上的任务同时可以有多个生产者往队...

			
		

	





	

		

			

				
					
Python在线程中使用安全队列

				
			

			

				

					不定时分享最优质的网络技术与教程，满满的干货。
				

				

					07-08
					
					1074
					
				

			

		

		

			
				
生产者每秒向队列中添加一个数字，消费者每两秒从队列中处理一个数字。从队列中获取项目并对其进行处理的函数。要在不阻塞的情况下从队列中获取项目，可以将 block 参数设置为。方法从队列中获取项目时，它可能需要在任务完成之前对其进行处理。要将项目添加到大小有限的队列并超时阻塞，可以使用如下。方法将阻塞，直到有一个项目可用于从队列中检索。要从队列中获取项目并在时间限制内阻塞，可以使用。首先，定义将1 到 6 的数字添加到队列中的。一旦队列已满，将无法向队列中添加项目。要将项目添加到队列中，可以使用如下。

			
		

	





	

		

			

				
					
python 多线程的同步机制 以python2例程的方式讲解了python 多线程的同步 常用的方法，主要是锁、条件同步、队列

				
			

			

				

					08-18
				

			

		

		

			
				
条件同步允许线程在满足特定条件后继续执行，而队列则提供了一种线程间安全传递数据的途径。在编写多线程程序时，合理使用这些同步机制可以避免数据竞争，防止死锁，并提高程序的稳定性和效率。  Python3环境  虽然...

			
		

	





	

		

			

				
					
6.Python多线程讲解（超级详细）

				
			

			

				

					weixin_39987031的博客
				

				

					08-23
					
					963
					
				

			

		

		

			
				
本文详细介绍了Python多线程相关知识，包括线程创建、线程安全、线程同步等

			
		

	





	

		

			

				
					
python 多进程队列数据处理详解

				
			

			

				

					09-18
				

			

		

		

			
				
首先，我们看到标题提到了“Python多进程队列数据处理”，这是一个涉及到Python多线程或多进程编程的高级话题。在多核心的现代计算机中，多进程是提高程序性能的一个常见手段，尤其是当面对大量数据处理时，可以让...

			
		

	





	

		

			

				
					
Python3多线程爬虫实例讲解代码

				
			

			

				

					09-20
				

			

		

		

			
				
### Python3多线程爬虫实例讲解  #### 一、多线程爬虫概述  多线程技术在Python中主要用于解决程序并发问题，通过利用CPU的多核优势提高程序执行效率。在Python3中，主要使用`threading`模块来实现多线程编程。与...

			
		

	





	

		

			

				
					
Python教程：一文掌握Python多线程（很详细）_python 多线程教程

				
			

			

				

					2301_76323084的博客
				

				

					04-21
					
					1555
					
				

			

		

		

			
				
链图片转存中…(img-Odm1w7iU-1713669739824)]

			
		

	





	

		

			

				
					
python线程安全队列

				
			

			

				

					LoveL_T的博客
				

				

					11-22
					
					4608
					
				

			

		

		

			
				
一直困扰我的问题，在博客园和优快云中都查阅过资料，答案千奇百怪，查阅官网跟几位大牛交流后做了一个小总结：

python中的list，dict，set，tuple都不是线程全队列。因为例如list在append()或者remove()的时候，资源是共享的，然后python没有在这些队列里面封装锁。但python中的queue队列属于线程安全，他底部封装了锁。

所谓线程安全，就是一个线程在同一时...

			
		

	





	

		

			

				
					
python线程安全队列用法

				
			

			

				

					weixin_34117211的博客
				

				

					06-05
					
					223
					
				

			

		

		

			
				
2019独角兽企业重金招聘Python工程师标准>>>   
                                        
         ...

			
		

	





	

		

			

				
					
【Python学习篇】线程安全队列Queue

				
			

			

				

					C-Jonn
				

				

					03-06
					
					2376
					
				

			

		

		

			
				
队列是线程间最常用的交换数据的形式，Queue模块实现了线程安全的队列，尤其适合多线程编程。Queue模块实现了三种类型队列：
❑Queue Queue：一个先进先出（FIFO）的队列，最先加入队列的元素最先取出；
❑LifoQueue LifoQueue：一个后进先出（LIFO）的队列，最后加入队列的元素最先取出；❑PriorityQueue PriorityQueue：优先级队列，队列中的元素...

			
		

	





	

		

			

				
					
Ｐython Queue 线程安全队列

				
			

			

				

					weixin_34384915的博客
				

				

					07-08
					
					1586
					
				

			

		

		

			
				
2019独角兽企业重金招聘Python工程师标准>>>   
                                        
         ...

			
		

	





	

		

			

				
					
Python queue模块详解：多线程安全的队列操作

				
			

			

				

					GitHub_miao的博客
				

				

					03-22
					
					1027
					
				

			

		

		

			
				
更多Python学习内容：ipengtao.com在Python中，queue模块提供了多线程安全的队列操作，用于实现线程间的数据通信和同步。本文将深入探讨queue模块的使用方法、常见队列类型、线程安全机制和示例代码，帮助大家更好地理解和应用队列操作。queue模块简介queue模块是Python标准库中的一部分，用于实现多线程安全的队列操作。它提供了几种常见的队列类型，包括先进先出队列（FIF...

			
		

	





	

		

			

				
					
Python----线程(Threading)---线程安全问题 & 互斥锁 & 队列

				
			

			

				

					Alien-Hu
				

				

					02-22
					
					4471
					
				

			

		

		

			
				
文章目录1.线程安全的问题？2.线程安全产生的根源？3.原子操作？4.线程锁---互斥锁？
1.线程安全的问题？

因为线程之间存在资源竞争的情况，也就是说一个全局变量经过多个线程的共同操作，最终的结果出出现异常情况，这就是线程安全的问题

num = 0


def sum_one(quantity):
    global num
    for index in range(quantity):
        num += 1
    return num


t1 = Thread(target=

			
		

	





	

		

			

				
					
108、Python并发编程：一文搞懂队列及Python中的线程安全队列

				
			

			

				

					南宫理的日知录
				

				

					11-15
					
					974
					
				

			

		

		

			
				
如果有科班出身的同学，一定曾经被本科的一门核心基础课程——《数据结构和算法》折磨过。读书期间，为了考试，也许只是死记硬背知识点了，不晓得实际上有什么用。但是，有了一定的工作实践之后，再回看哪些基础课程，一定会有更加深刻的体会。队列的概念及设计理念队列（Queue）是一种非常重要的数据结构，它提供一种先进先出（FIFO）的数据处理方式。队列再许多计算机科学和实际应用中都发挥着至关重要的作用。队列的设计理念主要有：1、先进先出（FIFO）：队列遵循先进先出的原则，最先进入队列的元素最先被处理。

			
		

	





	

		

			

				
					
python线程讲解

				
			

			

				

					07-25
				

			

		

		

			
				
在 Python 中，`threading` 模块提供了用于多线程编程的接口，允许程序同时运行多个线程，从而提高程序的并发性。尽管 Python 的全局解释器锁（GIL）限制了同一时间只有一个线程执行 Python 字节码，但多线程仍然适用于 I/O 密集型任务，例如网络请求、文件读写等，因为这些任务在等待时可以释放 GIL，让其他线程运行。

### 线程的基本工作原理

线程是操作系统调度的最小执行单元，一个进程可以包含多个线程，它们共享进程的内存空间和资源。Python 的 `threading` 模块封装了底层操作系统的线程管理，提供了跨平台的线程创建、启动和同步机制。

线程的生命周期包括以下几个状态：创建、就绪、运行、阻塞和终止。通过 `Thread` 类创建线程后，调用 `start()` 方法使其进入就绪状态，等待调度器分配 CPU 时间片执行。

### 线程的创建与启动

通过 `threading.Thread` 类可以创建一个新的线程对象，指定目标函数和参数。以下是一个简单的线程创建和启动示例：

```python
import threading

def thread_job():
    print(f'This is an added Thread, number is {threading.current_thread()}')

def main():
    added_thread = threading.Thread(target=thread_job)
    added_thread.start()
    print(f'Active thread count: {threading.active_count()}')
    print(f'Enumerate threads: {threading.enumerate()}')
    print(f'Current thread: {threading.current_thread()}')

if __name__ == "__main__":
    main()
```

### 线程的同步与 `join()` 方法

当主线程启动子线程后，默认情况下主线程不会等待子线程完成。为了确保主线程等待所有子线程执行完毕再继续执行，可以使用 `join()` 方法。例如：

```python
import threading
import time

def thread_job():
    print("T1 start")
    for i in range(10):
        time.sleep(0.1)
    print("T1 finish")

def main():
    added_thread = threading.Thread(target=thread_job, name="T1")
    added_thread.start()
    added_thread.join()
    print("all done")

if __name__ == "__main__":
    main()
```

### 多线程与性能对比

在 I/O 密集型任务中，多线程可以显著提高程序的执行效率。例如，在爬虫应用中，多个线程可以同时发起 HTTP 请求，而不是串行等待每个请求完成。以下是一个单线程与多线程爬虫的性能对比示例：

```python
import blog_spider
import threading
import time

def single_thread():
    print("single_thread begin")
    for url in blog_spider.urls:
        blog_spider.craw(url)
    print("single_thread end")

def multi_thread():
    print("multi_thread begin")
    threads = []
    for url in blog_spider.urls:
        threads.append(threading.Thread(target=blog_spider.craw, args=(url,)))
    for thread in threads:
        thread.start()
    for thread in threads:
        thread.join()
    print("multi_thread end")

if __name__ == '__main__':
    start = time.time()
    single_thread()
    end = time.time()
    print(f"single thread cost: {end - start}")

    start = time.time()
    multi_thread()
    end = time.time()
    print(f"multi thread cost: {end - start}")
```

### 多线程与队列结合实现任务调度

在实际应用中，多线程常与 `Queue` 模块结合使用，实现线程安全的任务队列。以下是一个使用 `Queue` 实现多线程求和的示例：

```python
import threading
from queue import Queue
import copy
import time

def job(l, q):
    res = sum(l)
    q.put(res)

def multithreading(l):
    q = Queue()
    threads = []
    for i in range(4):
        t = threading.Thread(target=job, args=(copy.copy(l), q), name=f'T{i}')
        t.start()
        threads.append(t)
    [t.join() for t in threads]
    total = 0
    for _ in range(4):
        total += q.get()
    print(total)

if __name__ == '__main__':
    l = list(range(1000000))
    s_t = time.time()
    multithreading(l)
    print(f'multithreading: {time.time() - s_t}')
```

### 相关问题

1. Python 中的全局解释器锁（GIL）如何影响多线程程序的性能？
2. 如何在 Python 中实现线程间的通信与数据共享？
3. 多线程与多进程在 Python 中的应用场景有何不同？
4. 如何在 Python 中避免线程安全问题？
5. Python 中 `daemon` 线程的作用是什么？如何设置？

[^1] [^2] [^3] [^4]

			
		

	



              




          




        



    





    



      

      

        
      

      





	

		
评论 1

	

  
	




  

    

      添加红包
      
    

    

      

        
        

          
          
        

        
请填写红包祝福语或标题

      

      

        
        

          
          个
        

        
红包个数最小为10个

      

      

        
        

          
          元
        

        
红包金额最低5元

      

      

        
        

          当前余额3.43元
          前往充值 >
        

      

      

        

          需支付：10.00元
        

        
        
      

    

  





  

    
    
  

  

    
    
  








  

    

      

        

          

            
            
成就一亿技术人!

          

          

        

        

          

          

            领取后你会自动成为博主和红包主的粉丝
            规则
          

        

      

      

        

          

            
              
            
            

              
hope_wisdom
 发出的红包
            

          

        

        

          

          

          

        

      

    

    

  



      
      

      
实付元

      
使用余额支付

      

        

          

            
            点击重新获取
          

        

        
扫码支付

      

      

        
          
            
          
          
        
      

      

        
        钱包余额
          0
          

            
            

              

                
抵扣说明：

                
 1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
 2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

              

            

          

      

      余额充值