线程优先级队列

发表于 更新于 分类于
这是文章开头，显示在主页面，详情请点击此处。

简介 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
# coding:UTF8

# Python的Queue模块中提供了同步的、线程安全的队列类，包括FIFO（先入先出)队列Queue，LIFO（后入先出）队列LifoQueue，

# 和优先级队列PriorityQueue，优先级队列可以参考我的浙江大学算法与数据结构笔记，哈夫曼树、最大最小堆那块。

# 这些队列都实现了锁原语，能够在多线程中直接使用。可以使用队列来实现线程间的同步。

# 线程之间的同步就是指：

# 多个线程争先恐后抢着干活，到底哪个线程抢到了活干这个顺序是不确定的，但是，这个活被干的顺序却是确定的！！！

# 因为这个活 被按顺序写进了队列中。

#

# Queue模块中的常用方法:

#

# Queue.qsize() 返回队列的大小

# Queue.empty() 如果队列为空，返回True,反之False

# Queue.full() 如果队列满了，返回True,反之False

# Queue.full 与 maxsize 大小对应

# Queue.get([block[, timeout]])获取队列，timeout等待时间

# Queue.get_nowait() 相当Queue.get(False)

# Queue.put(item, block=True, timeout=None) 写入队列，timeout等待时间

# Queue.put_nowait(item) 相当 Queue.put(item, False)

# Queue.task_done() 在完成一项工作之后，Queue.task_done()函数向任务已经完成的队列发送一个信号

# Queue.join() 实际上意味着等到队列为空，再执行别的操作

import queue
import threading
import time

exitFlag = 0


class myThread(threading.Thread):
    def __init__(self, threadID, name, q):
        threading.Thread.__init__(self)
        self.threadID = threadID
        self.name = name
        self.q = q

    def run(self):
        print("Starting " + self.name)
        process_data(self.name, self.q)
        print("Exiting " + self.name)


def process_data(threadName, q):
    while not exitFlag:
        queueLock.acquire()
        if not q.empty():
            data = q.get()
            queueLock.release()
            print("%s processing %s" % (threadName, data))
        else:
            queueLock.release()
        time.sleep(1)


threadList = ["Thread-1", "Thread-2", "Thread-3"]
nameList = ["One", "Two", "Three", "Four", "Five"]
queueLock = threading.Lock()
workQueue = queue.Queue(10)
threads = []
threadID = 1

# 创建新线程

for tName in threadList:
    thread = myThread(threadID, tName, workQueue) # 用继承线程类的的方式 创建线程类
    thread.start()  # 自动调用线程类的run方法
    threads.append(thread)   # 放入线程list 让后续代码的操作简洁。
    threadID += 1

# 填充队列      填充时 加锁，让它不被线程类的无限取值操作打扰

queueLock.acquire()
for word in nameList:
    workQueue.put(word)
queueLock.release()

# 等待队列清空

while not workQueue.empty():
    pass

# 通知线程是时候退出

exitFlag = 1

# 等待所有线程完成

for t in threads:
    t.join()
print("Exiting Main Thread")