孤荷凌寒自学python第四十三天python 的线程同步之Queue对象

 孤荷凌寒自学python第四十三天python的线程同步之Queue对象

（完整学习过程屏幕记录视频地址在文末，手写笔记在文末）

Queue对象是直接操作队列池的对象，队列中可以存放多种对象，当然也就可以存放线程对象，将多个线程对象存放于队列池中之后，就能非常显式的操作各个线程，非常方便。这是今天学习Queue的皮毛之后的感受，第一次感觉对线程有了非常完全的掌控，不像最初学习Lock与RLock那样，那时感觉完全没有掌控住线程。

一、  引用queue模块

Queue来自于模块queue

注意queue模块的首字母是小写的；而类名称Queue的名称首字母是大写的。

因此使用前必须 声明引用queue模块：

import queue

二、  得到queue模块中的三个相关队列类的对象实体（测试代码统一在后测试）

在queue模块中其实有三个与队列相关的类

1

Queue

新的Queue对象=queue. Queue([maxsize])

Queue是指一个 先进先出 的队列，即先进入队列 的对象，取出时也先被取出来。

缩写为：Fifo （First  in  first  out）

2

LifoQueue

新的LifoQueue对象=queue. LifoQueue([maxsize])

LifoQueue是指一个 后进先出 的队列，即后进入队列 的对象，取出时却会被先取出来。

缩写为：Lifo （Last  in  first  out）

3

PriorityQueue

新的PriorityQueue对象=queue. PriorityQueue ([maxsize])

PriorityQueue是指一个 优先级 队列，即不管进入队列 的顺序如何，取出时都按对象标注的 优先级来安排 取出顺序，优先级数字小的对象会被优先取出来 。

由于初学乍到，没有深入学习PriorityQueue，发现它的用法较前两个对象是不同的。

【maxsize】可选形参如果指定 了大于0的实际参数，那么就表示指定了这个队列对象的 最大容量（就是说可以容下多少个对象）。如果没有指定这个形参的实参或指定的实参小于1，那么都表示这个队列的容量是无限大的。

三、  Queue对象的主要方法（测试代码统一在后测试）

1

Queue对象 . put(对象[,block=True[,timeout=0]])

此方法用于将一个对象放入队列中，其中可选形参block=True,说明默认值是True,此时表示放入队列是阻塞式的，阻塞线程的时间由timeout决定。

关于阻塞式放入，我目前的理解是，如果 队列 的最大容量已经满了，但也要等待队列中有空位时才将对象放入。这种情况下不会报错，因为在阻塞下等待队列中有空位发生，就马上放进去。不过如果指定有timeout时间，则时间用完就不再阻塞以等待了。

如果 block=False,那么一旦队列中没有空位以将对象放入队列中，那么，就直接报错。

2

Queue对象 . get([,block=True[,timeout=0]])

此方法将取出队列中当前按优先顺序应当被取出来 的下一个对象，将返回一个对象。

其中可选形参block=True,说明默认值是True,此时表示取出队列中的元素是阻塞式的，阻塞线程的时间由timeout决定。

关于阻塞式取出，我目前的理解是，如果 队列 中已经没有对象了(队列为空)，但也要等待队列中有对象时才继续取出。这种情况下不会报错，因为在阻塞下等待队列中有对象发生，就马上取出来。不过如果 指定有timeout时间，则时间用完就不再阻塞以等待了。

如果 block=False,那么一旦队列中已经没有对象供取出，那么，就直接报错。

3

Queue对象 . qsize()

得到队列中当前的对象个数。

4

Queue对象 . maxsize()

得到队列中当前定义时设定的最大容量个数。

5

Queue对象 . empty()

此方法将返回队列是否已经为空，将返回一个布尔对象。

6

Queue对象 . not_empty()

此方法将返回队列是否不是空的，将返回一个布尔对象。

7

Queue对象 . full()

此方法将返回队列是否已经装满，将返回一个布尔对象。

8

Queue对象 . join()

执行此方法将等待队列中所有元素都被取出，队列为空时才执行后续操作。

四、  将文件由两个线程反复同步写和读的实现由Queue队列来实现

代码如下：

importthreading

import queue

fromdatetime import datetime

from time import sleep

strf='1.txt'

def read(n):

with open(strf,'r',encoding='utf-8') as f:

lstA=f.readlines()

print('读取第' + str(n) + '次' + str(lstA)  + '\n')

def write(n):

with open(strf,'w',encoding='utf-8') as f:

lstA=['写入','第' + str(n) + '次']

f.writelines(lstA)

#sleep(1)

print(str(lstA) +'\n')

def main():

q=queue.Queue(20)

x=range(10)

for n in x:

tread=threading.Thread(target=read,args=(n,))

twrite=threading.Thread(target=write,args=(n,))

q.put(twrite)

q.put(tread)

x=range(20)

for n in x:

t=q.get()

print('当前队列中还有对象：' + str(q.qsize())+ '个\n')

t.start()

t.join()

#q.join()

print('主线程结束。')

if __name__=='__main__':

main()

运行结果如下：

当前队列中还有对象：19个

['写入', '第0次']

当前队列中还有对象：18个

读取第0次['写入第0次']

当前队列中还有对象：17个

['写入', '第1次']

当前队列中还有对象：16个

读取第1次['写入第1次']

当前队列中还有对象：15个

['写入', '第2次']

当前队列中还有对象：14个

读取第2次['写入第2次']

当前队列中还有对象：13个

['写入', '第3次']

当前队列中还有对象：12个

读取第3次['写入第3次']

当前队列中还有对象：11个

['写入', '第4次']

当前队列中还有对象：10个

读取第4次['写入第4次']

当前队列中还有对象：9个

['写入', '第5次']

当前队列中还有对象：8个

读取第5次['写入第5次']

当前队列中还有对象：7个

['写入', '第6次']

当前队列中还有对象：6个

读取第6次['写入第6次']

当前队列中还有对象：5个

['写入', '第7次']

当前队列中还有对象：4个

读取第7次['写入第7次']

当前队列中还有对象：3个

['写入', '第8次']

当前队列中还有对象：2个

读取第8次['写入第8次']

当前队列中还有对象：1个

['写入', '第9次']

当前队列中还有对象：0个

读取第9次['写入第9次']

主线程结束。

从结果中看出，读写各十次都是成功的，且读写交替进行，符合同步要求，且读写没有冲突。

五、  将文件由两个线程反复同步写和读的实现由LifoQueue队列来实现

代码如下：

importthreading

import queue

fromdatetime import datetime

from time import sleep

strf='1.txt'

def read(n):

with open(strf,'r',encoding='utf-8') as f:

lstA=f.readlines()

print('读取第' + str(n) + '次' + str(lstA)  + '\n')

def write(n):

with open(strf,'w',encoding='utf-8') as f:

lstA=['写入','第' + str(n) + '次']

f.writelines(lstA)

#sleep(1)

print(str(lstA) +'\n')

def main():

x=range(10)

q=queue.LifoQueue(20)

for n in x :

tread=threading.Thread(target=read,args=(n,))

twrite=threading.Thread(target=write,args=(n,))

q.put(tread)

q.put(twrite)

x=range(q.maxsize)

for n in x:

t=q.get()

t.start()

t.join()

print('主线程结束。')

if __name__=='__main__':

main()

运行结果：

['写入', '第9次']

读取第9次['写入第9次']

['写入', '第8次']

读取第8次['写入第8次']

['写入', '第7次']

读取第7次['写入第7次']

['写入', '第6次']

读取第6次['写入第6次']

['写入', '第5次']

读取第5次['写入第5次']

['写入', '第4次']

读取第4次['写入第4次']

['写入', '第3次']

读取第3次['写入第3次']

['写入', '第2次']

读取第2次['写入第2次']

['写入', '第1次']

读取第1次['写入第1次']

['写入', '第0次']

读取第0次['写入第0次']

主线程结束。

——————————

今天整理的学习笔记完成，最后例行说明下我的自学思路：

根据过去多年我自学各种编程语言的经历，认为只有真正体验式，解决实际问题式的学习才会有真正的效果，即让学习实际发生。在2004年的时候我开始在一个乡村小学自学电脑 并学习vb6编程语言，没有学习同伴，也没有高师在上，甚至电脑都是孤岛（乡村那时还没有网络），有的只是一本旧书，在痛苦的自学摸索中，我找到适应自己零基础的学习方法：首先是每读书的一小节就作相应的手写笔记，第二步就是上机测试每一个笔记内容是否实现，其中会发现书中讲的其实有出入或错误，第三步就是在上机测试之后，将笔记改为电子版，形成最终的修订好的正确无误的学习笔记。

通过反复尝试错误，在那个没有分享与交流的黑暗时期我摸黑学会了VB6，尔后接触了其它语言，也曾听过付费视频课程，结果发现也许自己学历果然太低，就算是零基础的入门课程，其实也难以跟上进度，讲师的教学多数出现对初学者的实际情况并不了解的情况，况且学习者的个体也存在差异呢？当然更可怕的是收费课程的价格往往是自己难以承受的。

于是我的所有编程学习都改为了自学，继续自己的三步学习笔记法的学习之路。

当然自学的最大问题是会走那么多的弯路，没有导师直接输入式的教学来得直接，好在网络给我们带来无限搜索的机会，大家在网络上的学习日志带给我们共享交流的机会，而QQ群等交流平台、网络社区的成立，我们可以一起自学，互相批评交流，也可以获得更有效，更自主的自学成果。

于是我以人生已过半的年龄，决定继续我的编程自学之路，开始学习python，只希望与大家共同交流，一个人的独行是可怕的，只有一群人的共同前进才是有希望的。

诚挚期待您的交流分享批评指点！欢迎联系我加入从零开始的自学联盟。

这个时代互联网成为了一种基础设施的存在，于是本来在孤独学习之路上的我们变得不再孤独，因为网络就是一个新的客厅，我们时刻都可以进行沙龙活动。

非常乐意能与大家一起交流自己自学心得和发现，更希望大家能够对我学习过程中的错误给予指点——是的，这样我就能有许多免费的高师了——这也是分享时代，社区时代带来的好福利，我相信大家会的，是吧！

根据完全共享的精神，开源互助的理念，我的个人自学录制过程是全部按4K高清视频录制的,从手写笔记到验证手写笔记的上机操作过程全程录制，但因为4K高清文件太大均超过5G以上，所以无法上传至网络，如有需要可联系我QQ578652607对传，乐意分享。上传分享到百度网盘的只是压缩后的720P的视频。

我的学习过程录像百度盘地址分享如下：（清晰度：1280x720）

链接：https://pan.baidu.com/s/19BbmLmhXRgtdSXWMWtmabw

提取码：dy3p

Bilibili:

https://www.bilibili.com/video/av38090801/

喜马拉雅语音笔记：
https://www.ximalaya.com/keji/19103006/146250540