线程队列

1 基本语法和用法

  1. put 往线程队列里防止,超过队列长度,直接阻塞
  2. get 从队列中取值,如果获取不到,直接阻塞
  3. put_nowait: 如果放入的值超过队列长度,直接报错(linux)
  4. get_nowait: 如果获取的值已经没有了,直接报错

(1) queue 先进先出

  1. from queue import Queue
  2. q = Queue()
  3. q.put(11)
  4. q.put(22)
  5. print(q.get())
  6. print(q.get_nowait())

执行

  1. [root@node10 python]# python3 test.py
  2. 11
  3. 22

直接报错

  1. from queue import Queue
  2. q = Queue()
  3. q.put(11)
  4. q.put(22)
  5. print(q.get())
  6. print(q.get_nowait())
  7. print(q.get_nowait())

执行

指定队列长度

  1. from queue import Queue
  2. q2 = Queue(2)
  3. q2.put(33)
  4. q2.put(44)
  5. q2.put(55)

直接阻塞

使用put_nowait报错

LifoQueue 后进先出

数据结构中,栈队列的一种储存顺序

  1. from queue import LifoQueue
  2. lq = LifoQueue()
  3. lq.put(55)
  4. lq.put(66)
  5. print(lq.get())
  6. print(lq.get())

执行

  1. [root@node10 python]# python3 test.py
  2. 66
  3. 55

PriorityQueue 按照优先级顺序排列

  1. 默认按照数字大小排序,然后会按照ascii编码在从小到大排序
  2. 先写先排,后写后排
  1. from queue import PriorityQueue
  2. pq = PriorityQueue()
  3. pq.put( (12,"John") )
  4. pq.put( (6,"Jim") )
  5. pq.put( (19,"Tom") )
  6. pq.put( (8,"Lucy") )
  7.  
  8. print(pq.get())
  9. print(pq.get())
  10. print(pq.get())
  11. print(pq.get())

执行

  1. [root@node10 python]# python3 test.py
  2. (6, 'Jim')
  3. (8, 'Lucy')
  4. (12, 'John')
  5. (19, 'Tom')

当数字一样  按照ascsi值

  1. from queue import PriorityQueue
  2. pq = PriorityQueue()
  3. pq.put( (12,"John") )
  4. pq.put( (6,"Jim") )
  5. pq.put( (19,"Tom") )
  6. pq.put( (19,"Lucy") )
  7.  
  8. print(pq.get())
  9. print(pq.get())
  10. print(pq.get())
  11. print(pq.get())

执行

  1. [root@node10 python]# python3 test.py
  2. (6, 'Jim')
  3. (12, 'John')
  4. (19, 'Lucy')
  5. (19, 'Tom')

单独一个元素,必须放同一种类型

  1. from queue import PriorityQueue
  2. pq = PriorityQueue()
  3. pg = PriorityQueue()
  4. pg.put(13)
  5. pg.put(18)
  6. pg.put(3)
  7. print(pg.get())
  8. print(pg.get())
  9. print(pg.get())

执行

  1. [root@node10 python]# python3 test.py
  2. 3
  3. 13
  4. 18

如果不同类型

  1. from queue import PriorityQueue
  2. pq = PriorityQueue()
  3. pg = PriorityQueue()
  4. pg.put(13)
  5. pg.put(18)
  6. pg.put(3)
  7. pg.put("sdfsdf")
  8. print(pg.get())
  9. print(pg.get())
  10. print(pg.get())

执行

字符串类型

  1. from queue import PriorityQueue
  2. pg1 = PriorityQueue()
  3. pg1.put("ab")
  4. pg1.put("cc")
  5. print(pg1.get())
  6. print(pg1.get())

执行

  1. [root@node10 python]# python3 test.py
  2. ab
  3. cc

2 新版进程池,线程池

进程池 允许cpu并行

执行一个进程,如果使用了进程池,是要控制进程并行数量

  1. from concurrent.futures import ProcessPoolExecutor,ThreadPoolExecutor
  2. import os,time
  3. def func(i):
  4. print ("process:",i,os.getpid())
  5. time.sleep(3)
  6. print ("process:end")
  7. return 6666
  8. # 创建进程池对象,8是代表最大8个进程,ProcessPoolExecutor 后面的参数默认是cpu的最大逻辑处理器核心数.
  9. p = ProcessPoolExecutor(8)
  10. #异步触发进程,res 接收的是对象,这个对象可以通过result()来获取返回值
  11. res = p.submit(func,1)
  12. #获取进程任务的返回值
  13. res2 = res.result()
  14. #shutdown,等待所有子进程执行完毕之后,在向下执行,类似于join
  15. p.shutdown()
  16.  
  17. print("主进程执行完毕")

执行

  1. [root@node10 python]# python3 test.py
  2. process: 1 42441
  3. process:end
  4. 主进程执行完毕

执行多个进程,如果使用了进程池,是要控制进程并行数量

  1. from concurrent.futures import ProcessPoolExecutor,ThreadPoolExecutor
  2. import os,time
  3. def func(i):
  4. print ("process:",i,os.getpid())
  5. time.sleep(3)
  6. print ("process:end")
  7. return 6666
  8. # 创建进程池对象
  9. p = ProcessPoolExecutor(8)
  10. #异步触发进程,res 接收的是对象,这个对象可以通过result()来获取返回值
  11. for i in range(12):
  12. res = p.submit(func,i)
  13. #获取进程任务的返回值
  14. res2 = res.result()
  15. #shutdown,等待所有子进程执行完毕之后,在向下执行,类似于join
  16. p.shutdown()
  17.  
  18. print("主进程执行完毕")

执行

  1. [root@node10 python]# python3 test.py
  2. process: 0 42457
  3. process: 1 42458
  4. process: 2 42459
  5. process: 3 42460
  6. process: 4 42461
  7. process: 5 42462
  8. process: 6 42463
  9. process: 7 42464
  10. process:end
  11. process:end
  12. process:end
  13. process: 8 42463
  14. process: 9 42457
  15. process: 10 42459
  16. process:end
  17. process: 11 42462
  18. process:end
  19. process:end
  20. process:end
  21. process:end
  22. process:end
  23. process:end
  24. process:end
  25. process:end
  26. 主进程执行完毕

3 线程池

  1. from concurrent.futures import ProcessPoolExecutor,ThreadPoolExecutor
  2. from threading import current_thread as cthread
  3. import os,time
  4. def func(i):
  5. print("thread",i,cthread().ident)
  6. time.sleep(3)
  7. print("thread %s end %s"%(i))
  8.  
  9. #创建线程池。括号里面可以指定并发的线程数
  10. tp = ThreadPoolExecutor(4)
  11. for i in range(20):
  12. tp.submit(func,i)
  13. tp.shutdown()
  14. print("主线程执行结束。。。")

执行

  1. [root@node10 python]# python3 test.py
  2. thread 0 140712745903872
  3. thread 1 140712737511168
  4. thread 2 140712658073344
  5. thread 3 140712649680640
  6. thread 4 140712745903872
  7. thread 5 140712658073344
  8. thread 6 140712737511168
  9. thread 7 140712649680640
  10. thread 8 140712737511168
  11. thread 9 140712658073344
  12. thread 10 140712745903872
  13. thread 11 140712649680640
  14. thread 12 140712737511168
  15. thread 13 140712745903872
  16. thread 14 140712658073344
  17. thread 15 140712649680640
  18. thread 16 140712745903872
  19. thread 17 140712737511168
  20. thread 18 140712649680640
  21. thread 19 140712658073344
  22. 主线程执行结束。。。

4 GIL锁

一个进程中的多条线程同一时间只能被一个cpu执行,不能实现并行操作.
想要解决:更换Jpython 或者 PyPy解释器
为什么加锁:
python是解释性语言,编译一行,就执行一行,不能提前规划系统资源,进行全局分配,根本原因是历史遗留问题.
程序分为两大类:

  • 计算密集型程序,通过c语言改写python部分模块来实现
  • io密集型程序,类似于python_web 运维,数据分析 都可以使用

线程池的返回值

  1. from concurrent.futures import ProcessPoolExecutor,ThreadPoolExecutor
  2. from threading import current_thread as cthread
  3. import os,time
  4. def func(i):
  5. #获取当前线程号
  6. print("thread",i,cthread().ident)
  7. time.sleep(1)
  8. #返回线程号,获取返回值,会加阻塞,无需shutdown
  9. return cthread().ident
  10.  
  11. #创建线程池。括号里面可以指定并发的线程数
  12. tp = ThreadPoolExecutor(6)
  13. lst = []
  14. setvar = set()
  15. for i in range(12):
  16. #异步出发
  17. res = tp.submit(func,i)
  18. lst.append(res)
  19. for i in lst:
  20. #获取该进程对象的返回值
  21. print (i.result())
        #塞到集合里面,可以去重,验证
  22. setvar.add(i.result())
    #打印所有的线程号
  23. print (setvar)
  24. print("主线程执行结束。。。")

执行

  1. [root@node10 python]# python3 test.py
  2. thread 0 140423614576384
  3. thread 1 140423606183680
  4. thread 2 140423597790976
  5. thread 3 140423589398272
  6. thread 4 140423581005568
  7. thread 5 140423572612864
  8. thread <Future at 0x7fb6f7ad4b70 state=running> 140423597790976
  9. thread <Future at 0x7fb6f7ad4b70 state=running> 140423572612864
  10. thread <Future at 0x7fb6f7ad4b70 state=running> 140423589398272
  11. thread <Future at 0x7fb6f7ad4b70 state=running> 140423606183680
  12. thread <Future at 0x7fb6f7ad4b70 state=running> 140423581005568
  13. thread <Future at 0x7fb6f7ad4b70 state=finished returned int> 140423614576384
  14. 140423614576384
  15. 140423606183680
  16. 140423597790976
  17. 140423589398272
  18. 140423581005568
  19. 140423572612864
  20. 140423597790976
  21. 140423572612864
  22. 140423589398272
  23. 140423606183680
  24. 140423581005568
  25. 140423614576384
  26. {140423614576384, 140423606183680, 140423581005568, 140423597790976, 140423589398272, 140423572612864}
  27. 主线程执行结束。。。

5 map返回迭代器

  1. from concurrent.futures import ProcessPoolExecutor,ThreadPoolExecutor
  2. import os,time
  3. from threading import current_thread as cthread
  4. def func(i):
  5. time.sleep(0.2)
  6. print("thread",i,cthread().ident)
  7. print("thread .. end %s" % (i))
  8. return "*" * i
  9.  
  10. tp = ThreadPoolExecutor(5)
  11. it = tp.map(func,range(20))
  12. tp.shutdown()
  13. print("<===>")
  14. from collections import Iterator
  15. res = isinstance(it,Iterator)
  16. print(res)
  17. print(list(it))
  18.  
  19. # "1234567"
  20. # it = map(int,"1234567")
  21. # print(list(it))

执行

  1. [root@node10 python]# python3 test.py
  2. thread 0 140381751781120
  3. thread .. end 0
  4. thread 2 140381734995712
  5. thread .. end 2
  6. thread 1 140381743388416
  7. thread .. end 1
  8. thread 3 140381726603008
  9. thread .. end 3
  10. thread 4 140381718210304
  11. thread .. end 4
  12. thread 5 140381751781120
  13. thread 6 140381734995712
  14. thread .. end 5
  15. thread .. end 6
  16. thread 9 140381718210304
  17. thread 8 140381726603008
  18. thread .. end 8
  19. thread 7 140381743388416
  20. thread .. end 7
  21. thread .. end 9
  22. thread 14 140381718210304
  23. thread .. end 14
  24. thread 10 140381751781120
  25. thread .. end 10
  26. thread 11 140381734995712
  27. thread .. end 11
  28. thread 13 140381743388416
  29. thread .. end 13
  30. thread 12 140381726603008
  31. thread .. end 12
  32. thread 15 140381718210304
  33. thread .. end 15
  34. thread 19 140381726603008
  35. thread .. end 19
  36. thread 16 140381751781120
  37. thread .. end 16
  38. thread 18 140381743388416
  39. thread .. end 18
  40. thread 17 140381734995712
  41. thread .. end 17
  42. <===>
  43. True
  44. ['', '*', '**', '***', '****', '*****', '******', '*******', '********', '*********', '**********', '***********', '************', '*************', '**************', '***************', '****************', '*****************', '******************', '*******************']

045.Python线程队列的更多相关文章

  1. python 线程队列PriorityQueue(优先队列)(37)

    在 线程队列Queue / 线程队列LifoQueue 文章中分别介绍了先进先出队列Queue和先进后出队列LifoQueue,而今天给大家介绍的是最后一种:优先队列PriorityQueue,对队列 ...

  2. python 线程队列LifoQueue-LIFO(36)

    在 python线程队列Queue-FIFO  文章中已经介绍了 先进先出队列Queue,而今天给大家介绍的是第二种:线程队列LifoQueue-LIFO,数据先进后出类型,两者有什么区别呢? 一.队 ...

  3. python线程队列Queue-FIFO(35)

    之前的文章中讲解很多关于线程间通信的知识,比如:线程互斥锁lock,线程事件event,线程条件变量condition 等等,这些都是在开发中经常使用的内容,而今天继续给大家讲解一个更重要的知识点 — ...

  4. python 线程队列、线程池、全局解释器锁GIL

    一.线程队列 队列特性:取一个值少一个,只能取一次,没有值的时候会阻塞,队列满了,也会阻塞 queue队列 :使用import queue,用法与进程Queue一样 queue is especial ...

  5. python线程+队列(queue)

    ---恢复内容开始--- python的线程学习 用处 pocpiliang脚本的编写 函数式:调用 _thread 模块中的start_new_thread()函数来产生新线程.语法如下: _thr ...

  6. python线程池ThreadPoolExecutor(上)(38)

    在前面的文章中我们已经介绍了很多关于python线程相关的知识点,比如 线程互斥锁Lock / 线程事件Event / 线程条件变量Condition 等等,而今天给大家讲解的是 线程池ThreadP ...

  7. python全栈开发 * 线程队列 线程池 协程 * 180731

    一.线程队列 队列:1.Queue 先进先出 自带锁 数据安全 from queue import Queue from multiprocessing import Queue (IPC队列)2.L ...

  8. Python之线程 3 - 信号量、事件、线程队列与concurrent.futures模块

    一 信号量 二 事件 三 条件Condition 四 定时器(了解) 五 线程队列 六 标准模块-concurrent.futures 基本方法 ThreadPoolExecutor的简单使用 Pro ...

  9. Python进阶----异步同步,阻塞非阻塞,线程池(进程池)的异步+回调机制实行并发, 线程队列(Queue, LifoQueue,PriorityQueue), 事件Event,线程的三个状态(就绪,挂起,运行) ,***协程概念,yield模拟并发(有缺陷),Greenlet模块(手动切换),Gevent(协程并发)

    Python进阶----异步同步,阻塞非阻塞,线程池(进程池)的异步+回调机制实行并发, 线程队列(Queue, LifoQueue,PriorityQueue), 事件Event,线程的三个状态(就 ...

随机推荐

  1. Html5新增了什么

    h5新增了些什么 介绍 HTML5 是下一代的 HTML, 将成为 HTML.XHTML 以及 HTML DOM 的新标准. 起步 HTML5 是 W3C 与 WHATWG 合作的结果. 为 HTML ...

  2. html页面自定义文字水印效果案例

    在系统开发过程中,一些数据或页面比较敏感的地方,客户会要求实现水印效果,防止内部人员截图或拍照泄露信息. 自定义文字水印顾名思义就是利用js在完成页面渲染的同时,往页面的最底层动态生成多个带水印信息的 ...

  3. hello world!goodbye world~

    我有个朋友,做ios开发做了5年,年前回家转行赚大钱去了,这个标题,其实就是因他而生. 我本人做的.net开发,也差不多快5年时间了,在这个时候暂借博客园这个平台说几句心里话,骚了勿喷:) 其实我是个 ...

  4. 解决Linux无法读写U盘中的NTFS问题

    1 问题描述 由于笔者因为某些需要把Windows装在了U盘上面(在这里建议一下如果有需要请使用固态U盘),在Linux下挂载时,能读取但并不能写. 2 尝试的解决方案 2.1 remount 一开始 ...

  5. 2. linux下如何上传和下载文件

    一. 安装工具包 yum install -y lrzsz lrzsz是一个unix通信套件提供的X,Y,和ZModem文件传输协议,可以用在windows与linux 系统之间的文件传输,体积小速度 ...

  6. 004-Java中的运算符

    @ 目录 一.运算符 一.分类 二.算数运算符 三.关系运算符 四.逻辑运算符 五.赋值运算符 六.条件运算符(三目运算符) 七.+运算符 一.运算符 一.分类 二.算数运算符 加  $+$ 减  $ ...

  7. Day16_88_通过反射机制执行方法

    通过反射机制执行方法 * method.invoke(object,"admin","123"); * 代码 import java.lang.reflect. ...

  8. centos7安装kubernetes k8s 1.18

    可以参考其他网友的阿里云搭建k8s高可用集群(1.17.3) https://www.cnblogs.com/gmmy/p/12372805.html 准备四台centos7虚拟机,用来安装k8s集群 ...

  9. 1-OSI七层模型

    网络功能:数据传输 ISO(国际标准化组织) OSI七层模型---->网络通信工作流程的标准化 OSI七层模型 应用层:提供用户服务,具体功能由特定的程序而定. 表示层:数据的压缩优化,加密. ...

  10. Windows远程时无法复制文件--杀进程rdpclip.exe,然后再启动

    1.远程登陆到主机上 2.任务管理器杀进程rdpclip.exe 3.[开始],搜索rdpclip.exe,点击运行 此时重新复制文件,可以跨主机复制啦 原以为是公司网络限制,现在看来还是没那么先进嘛