python 多线程与队列

最新推荐文章于 2023-03-17 23:06:02 发布
最新推荐文章于 2023-03-17 23:06:02 发布
阅读量130 收藏
点赞数
原文链接：https://blog.csdn.net/wsp_1138886114/article/details/86431971
版权

队列-单线程

import threading
import queue#不是线程模块的队列
import time


class worker(threading.Thread):
    def __init__(self, queue):
        threading.Thread.__init__(self)
        self.queue = queue
        self.thread_stop = False

    def run(self):
        while not self.thread_stop:
            print(f"{self.name} id:{self.ident} 等待测试")
            try:
                task = q.get(block=True, timeout=2)  # 接收消息
            except queue.Empty:
                print("工作结束！ 我可以回家了!")
                self.thread_stop = True
                break
            print(f"\t工作任务:{task[0]} 任务编号:{task[1]}")
            print("\t工作中...")
            time.sleep(1.2)
            print("\t工作结束!")
            q.task_done()                           # 完成一个任务
            res = q.qsize()                         # 判断消息队列大小(队列中还有几个任务)
            if res > 0:
                print(f"\t还有{res}个任务要做，加油！")

    def stop(self):
        self.thread_stop = True


if __name__ == "__main__":
    q = queue.Queue(3)                                    # 创建队列（大小为3）
    worker = worker(q)                                    # 将队列加入类中
    print("***********************领导:开始工作!")
    worker.start()                                        # 启动类
    q.put(["produce cup!", 1], block=True, timeout=None)  # 向队列中添加元素，产生任务消息
    q.put(["produce desk!", 2], block=True, timeout=None)
    q.put(["produce apple!", 3], block=True, timeout=None)
    q.put(["produce banana!", 4], block=True, timeout=None)
    q.put(["produce bag!", 5], block=True, timeout=None)
    q.join()                                             # 等待所有任务完成
    print("***********************领导:所有任务完成!")

输出：

***********************领导:开始工作!
Thread-1 id:10344 等待测试
	工作任务:produce cup! 任务编号:1
	工作中...
	工作结束!
	还有3个任务要做，加油！
Thread-1 id:10344 等待测试
	工作任务:produce desk! 任务编号:2
	工作中...
	工作结束!
	还有3个任务要做，加油！
Thread-1 id:10344 等待测试
	工作任务:produce apple! 任务编号:3
	工作中...
	工作结束!
	还有2个任务要做，加油！
Thread-1 id:10344 等待测试
	工作任务:produce banana! 任务编号:4
	工作中...
	工作结束!
	还有1个任务要做，加油！
Thread-1 id:10344 等待测试
	工作任务:produce bag! 任务编号:5
	工作中...
	工作结束!
Thread-1 id:10344 等待测试
***********************领导:所有任务完成!
工作结束！ 我可以回家了!
[Finished in 8.1s]

队列-多线程

import threading
import time
import logging
from queue import Queue
logging.basicConfig(
    level=logging.INFO,
    format="%(asctime)s [*] %(message)s"
)
img_lists = ['lipei_00006.mp3', 'lipei_00007.mp3', 'lipei_00012.mp3', 'lipei_00014.mp3',
             'lipei_00021.mp3', 'lipei_00027.mp3', 'lipei_00028.mp3', 'lipei_00035.mp3',
             'lipei_00039.mp3', 'lipei_00044.mp3', 'lipei_00047.mp3', 'lipei_00049.mp3',
             'lipei_00057.mp3', 'lipei_00058.mp3', 'lipei_00059.mp3', 'lipei_00061.mp3',
             'lipei_00066.mp3', 'lipei_00068.mp3', 'lipei_00070.mp3', 'lipei_00081.mp3',
             'lipei_00087.mp3', 'lipei_00104.mp3', 'lipei_00106.mp3', 'lipei_00117.mp3',
             'lipei_00123.mp3', 'lipei_00129.mp3', ]


class Music_Cols(threading.Thread):
    def __init__(self, name, queue):
        super().__init__(name=name)
        self.queue = queue

    def run(self):
        global img_lists
        while True:
            try:
                music = img_lists.pop(0)
                self.queue.put(music)
            except IndexError:
                break


class Music_Play(threading.Thread):
    def __init__(self, name, queue):
        super().__init__(name=name)
        self.queue = queue

    def run(self):
        while True:
            if self.queue.not_empty:
                music = q.get()
                logging.info(f"{threading.current_thread()}正在播放{music}")
                time.sleep(2)
                q.task_done()
                logging.info(f'{music}播放结束')
            else:
                break


if __name__ == '__main__':
    q = Queue(10)
    mc_thread = Music_Cols('music_cols', q)
    mc_thread.setDaemon(True)       # 设置为守护进程，主线程退出时，子进程也kill掉
    mc_thread.start()               # 启动进程
    for _ in range(5):              # 设置线程个数（批量任务时，线程数不必太大，注意内存及CPU负载）
        mp_thread = Music_Play('music_play', q)
        mp_thread.setDaemon(True)
        mp_thread.start()
    q.join()                        # 线程阻塞（等待所有子线程处理完成，再退出）

输出：

2019-12-08 16:10:58,391 [*] <Music_Play(music_play, started daemon 12460)>正在播放lipei_00006.mp3
2019-12-08 16:10:58,407 [*] <Music_Play(music_play, started daemon 9084)>正在播放lipei_00007.mp3
2019-12-08 16:10:58,409 [*] <Music_Play(music_play, started daemon 11296)>正在播放lipei_00012.mp3
2019-12-08 16:10:58,410 [*] <Music_Play(music_play, started daemon 12048)>正在播放lipei_00014.mp3
2019-12-08 16:10:58,410 [*] <Music_Play(music_play, started daemon 8208)>正在播放lipei_00021.mp3
2019-12-08 16:11:00,411 [*] lipei_00021.mp3播放结束
2019-12-08 16:11:00,411 [*] lipei_00014.mp3播放结束
2019-12-08 16:11:00,411 [*] lipei_00012.mp3播放结束
2019-12-08 16:11:00,412 [*] <Music_Play(music_play, started daemon 11296)>正在播放lipei_00035.mp3
2019-12-08 16:11:00,411 [*] lipei_00006.mp3播放结束
2019-12-08 16:11:00,412 [*] <Music_Play(music_play, started daemon 12460)>正在播放lipei_00039.mp3
2019-12-08 16:11:00,411 [*] <Music_Play(music_play, started daemon 8208)>正在播放lipei_00027.mp3
2019-12-08 16:11:00,411 [*] lipei_00007.mp3播放结束
2019-12-08 16:11:00,412 [*] <Music_Play(music_play, started daemon 9084)>正在播放lipei_00044.mp3
2019-12-08 16:11:00,411 [*] <Music_Play(music_play, started daemon 12048)>正在播放lipei_00028.mp3
2019-12-08 16:11:02,415 [*] lipei_00028.mp3播放结束
2019-12-08 16:11:02,415 [*] lipei_00044.mp3播放结束
2019-12-08 16:11:02,415 [*] lipei_00027.mp3播放结束
2019-12-08 16:11:02,415 [*] lipei_00039.mp3播放结束
2019-12-08 16:11:02,415 [*] lipei_00035.mp3播放结束
2019-12-08 16:11:02,415 [*] <Music_Play(music_play, started daemon 12048)>正在播放lipei_00047.mp3
2019-12-08 16:11:02,415 [*] <Music_Play(music_play, started daemon 9084)>正在播放lipei_00049.mp3
2019-12-08 16:11:02,416 [*] <Music_Play(music_play, started daemon 8208)>正在播放lipei_00057.mp3
2019-12-08 16:11:02,416 [*] <Music_Play(music_play, started daemon 12460)>正在播放lipei_00058.mp3
2019-12-08 16:11:02,416 [*] <Music_Play(music_play, started daemon 11296)>正在播放lipei_00059.mp3
2019-12-08 16:11:04,418 [*] lipei_00059.mp3播放结束
2019-12-08 16:11:04,418 [*] lipei_00058.mp3播放结束
2019-12-08 16:11:04,418 [*] lipei_00057.mp3播放结束
2019-12-08 16:11:04,419 [*] lipei_00049.mp3播放结束
2019-12-08 16:11:04,419 [*] lipei_00047.mp3播放结束
2019-12-08 16:11:04,419 [*] <Music_Play(music_play, started daemon 11296)>正在播放lipei_00061.mp3
2019-12-08 16:11:04,419 [*] <Music_Play(music_play, started daemon 12460)>正在播放lipei_00066.mp3
2019-12-08 16:11:04,419 [*] <Music_Play(music_play, started daemon 8208)>正在播放lipei_00068.mp3
2019-12-08 16:11:04,420 [*] <Music_Play(music_play, started daemon 9084)>正在播放lipei_00070.mp3
2019-12-08 16:11:04,420 [*] <Music_Play(music_play, started daemon 12048)>正在播放lipei_00081.mp3
2019-12-08 16:11:06,423 [*] lipei_00068.mp3播放结束
2019-12-08 16:11:06,423 [*] <Music_Play(music_play, started daemon 8208)>正在播放lipei_00087.mp3
2019-12-08 16:11:06,423 [*] lipei_00081.mp3播放结束
2019-12-08 16:11:06,423 [*] lipei_00066.mp3播放结束
2019-12-08 16:11:06,423 [*] lipei_00061.mp3播放结束
2019-12-08 16:11:06,423 [*] lipei_00070.mp3播放结束
2019-12-08 16:11:06,423 [*] <Music_Play(music_play, started daemon 12048)>正在播放lipei_00104.mp3
2019-12-08 16:11:06,423 [*] <Music_Play(music_play, started daemon 12460)>正在播放lipei_00106.mp3
2019-12-08 16:11:06,423 [*] <Music_Play(music_play, started daemon 11296)>正在播放lipei_00117.mp3
2019-12-08 16:11:06,423 [*] <Music_Play(music_play, started daemon 9084)>正在播放lipei_00123.mp3
2019-12-08 16:11:08,426 [*] lipei_00117.mp3播放结束
2019-12-08 16:11:08,426 [*] <Music_Play(music_play, started daemon 11296)>正在播放lipei_00129.mp3
2019-12-08 16:11:08,426 [*] lipei_00123.mp3播放结束
2019-12-08 16:11:08,426 [*] lipei_00106.mp3播放结束
2019-12-08 16:11:08,426 [*] lipei_00104.mp3播放结束
2019-12-08 16:11:08,426 [*] lipei_00087.mp3播放结束
2019-12-08 16:11:10,428 [*] lipei_00129.mp3播放结束
[Finished in 12.2s]
迷心兔
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Python 多线程|thread,使用threading模块创建线程,线程同步,线程优先级队列（ Queue）
萧海的博客
12-29 704
多线程类似于同时执行多个不同程序，多线程运行有如下优点： 使用线程可以把占据长时间的程序中的任务放到后台去处理。 用户界面可以更加吸引人，比如用户点击了一个按钮去触发某些事件的处理，可以弹出一个进度条来显示处理的进度。 程序的运行速度可能加快。 在一些等待的任务实现上如用户输入、文件读写和网络收发数据等，线程就比较有用了。在这种情况下我们可以释放一些珍贵的资源如内存占用等等。 每个独立的线程有一个程序运行的入口、顺序执行序列和程序的出口。但是线程不能够独立执行，必须依存在应用程序中，由应用程序提供多个线
Python实现简单多线程任务队列
09-21
本文给大家介绍的是使用很简单的代码实现的多线程任务队列，给大家一个思路，希望对大家学习python能够有所帮助
python队列基本使用
weixin_30674525的博客
08-17 209
Python queue队列 作用： 　　　解耦：使程序直接实现松耦合，修改一个函数，不会有串联关系。 　　　提高处理效率：ＦＩＦＯ　＝　现进先出，ＬＩＦＯ　＝　后入先出。 队列： 　　队列可以并发的派多个线程，对排列的线程处理，并切每个需要处理线程只需要将请求的数据放入队列容器的内存中，线程不需要等待，当排列完毕处理完数据后，线程在准时来取数据即可。请求数据的线程只与这个队列容器...
python多线程实例_Python多线程和队列操作实例
weixin_39897687的博客
01-29 225
python3，开一个线程，间隔1秒把一个递增的数字写入队列，再开一个线程，从队列中取出数字并打印到终端复制代码 代码如下:#! /usr/bin/env python3import timeimport threadingimport queue# 一个线程，间隔一定的时间，把一个递增的数字写入队列# 生产者class Producer(threading.Thread):def __init_...
Python多线程——队列（Queue）
sjwzdh的博客
11-10 3006
Queue主要就是为多线程生产值、消费者之间线程通信提供服务，具有先进先出的数据结构。 首先我们组要明白为什么要使用队列，队列的性质， 多线程并发编程的重点，是线程之间共享数据的访问问题和线程之间的通信问题 为了解决线程之间数据共享问题， PYTHON 提供了一个数据类型【队列】可以用于在多线程并发模式下，安全的访问数据而不会造成数据共享冲突。 正常请求的多线程，如果是消费之和生产者，通过列表实现...
Python多线程和队列
weixin_54567607的博客
03-17 1801
在Python中，使用多线程和多进程可以同时执行多个任务，提高程序的执行效率和性能。但是，多线程和多进程之间有许多不同之处，需要根据实际应用场景选择合适的方式。
python多线程队列学习
码农云云的博客
09-12 180
python学习之多线程 线程几种状态： 初始化—>就绪/或等待---->运行时态---->死亡 每个线程一定会有一个name，线程的run()方法介绍线程就结束了，多线程中无法控制线程的调度(操作系统说了算)，但是可以通过别的方式来影响线程调度，比如互斥、死锁、条件变量、生产者与消费者。 1. 单线程 按顺序依次执行 import time def hello(): print("hello world") time.sleep(1) if __name__ == '__mai
浅谈python多线程和队列管理shell程序
09-21
### Python多线程与队列管理Shell程序详解 在Python编程中，多线程和队列管理是非常重要的技术，尤其当涉及到并发处理多个任务时。本文将深入探讨Python中的多线程以及如何利用队列来管理和监控这些线程的状态。 #...
Python多线程和队列操作实例
09-21
### Python多线程与队列操作详解 #### 一、多线程简介 在Python中，多线程是指允许多个线程同时运行的技术。它能够显著提高程序的执行效率，尤其是在处理I/O密集型任务时更为明显。通过合理利用多线程，可以让程序...
Python多线程通信queue队列用法实例分析
09-17
本篇将深入探讨Python多线程通信中queue队列的使用方法。 首先，队列是一种先进先出（FIFO，First-In-First-Out）的数据结构，这意味着第一个进入队列的元素也将是第一个离开队列的元素。在Python中，`queue`模块...
python多进程与多线程的区别-Python3多进程与多线程区别及使用（2.线程）
weixin_39604350的博客
11-11 192
threading模块简述：threading模块threading.currentThread(): 返回当前的线程变量。threading.enumerate(): 返回一个包含正在运行的线程的list。正在运行指线程启动后、结束前，不包括启动前和终止后的线程。threading.activeCount(): 返回正在运行的线程数量，与len(threading.enumerate())有相同...
python队列基本操作与多线程队列
侯小啾技术博客
02-03 2965
文章目录队列基本操作多线程队列 队列基本操作 from queue import Queue q = Queue(5) # 创建一个容量为5的队列。如果给一个小于0的数，则队列为无限大小。（这是官方的解释，实际不是无限大小，而是跟内存有关） # 存储数据 q.put(123) # 数值 q.put('hello world!') # 字符串 q.put(['hello', 'world']) # 列表 q.put(('hello', 'world')) # 元组 q.put({'hello'
linux ls directory,Linux 命令行：ls（list directory contents）
weixin_39968724的博客
05-15 234
简介ls(list)，用于列出文件夹下的文件和文件夹的信息。在没有任何参数的情况下，ls按字母顺序列出当前文件夹下的内容的名称，不递归子文件夹的内容，也不显示以“.”开头的文件。常用参数参数长参数描述-a--all不忽略以“.”开头的文件。-A--almost-all只忽略“.”和“..”，不忽略以“.”开头的文件。-B--ignore-backups忽略以“~”结尾的文件。-d--directo...
Python中的多线程与队列
vspiders的博客
06-18 5468
0x01 线程锁既然说到多线程，就会经常遇到多个线程共同操作一个单元或空间的情况，对该单元进行修改、获取等操作，为了避免各线程间的混乱操作，保证线程同步的正确性，很有必要引入线程锁的概念。线程锁，顾名思义，表示某一单元或空间只为某一线程所有，此时其他线程均无法进行操作，等待该线程操作完成并释放锁之后，其他线程才可继续利用该单元。Python中线程锁的用法很简单，使用Thread对象中的Lock方法...
Python多线程和队列结合demo
weixin_42625143的博客
07-08 4860
一、使用场景 大家都知道python的多线程不是真正的多线程，但是对于io类型的任务，多线程还是能发挥作用的。那么多个线程之间是如何进行变量共享的呢，很多时候我们可以借助queue模块，方便。今天就做一个学习。 二、threading模块 Python的多线程还是主要使用标准库threading，该库提供了更高级别、功能更全面的线程管理。 该模块提供的主要方法： threading.current...
python 多线程+queue
xiao_huocai的博客
07-07 9824
python的queue设计的是线程安全的，所以大家伙放心用吧！ python多线程的一种简单的实现如下:#!/usr/bin/env python # -*- coding: utf-8 -*- import threading import timedef fun(argv): print 'in', argv time.sleep(2)threads = [] #用于保
python 多线程结果队列
最新发布
08-08
Python中的多线程结果队列是一种机制，可以用于在多个线程之间共享和传递结果。当一个线程完成任务后，它可以将结果放入队列中，其他线程可以从队列中取出该结果进行进一步处理。 Python中常用的多线程结果队列是...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值