Python小记 多线程

---

threading 模块

• currentThread()：返回当前的线程变量
• enumerate()：返回一个包含正在运行的线程列表。启动前、终止的不包含
• acticeCount()：返回正在运行的线程数量。==len(threading.enumerate())

threading 的使用

1.Thread

Thread(group=None,
	target=None,	# 要运行的函数
	name=None,		# 
	args=(),		# 传入函数的参数元祖
	kwargs={},
	*,
	deamon=None
	)

import threading

def doit(data):
	for i in range(data):
		print(f'__{i}__')

t1 = threading.Thread(target=doit, args=(4))
t2 = threading.Thread(target=doit, args=(5))
t1.start()
t2.start()

---

2.继承Thread

• 重写run()方法

import threading

class Test(threading.Thread):
	def __init__(self, data):
		super.__init__()
		self.data = data
	def run():
		for i in range(self.data):
			print(f'__{i}__')

if __name__ == '__main__':
	th = []
	for i in [4, 6]:
		th.append(Test(i))
	for t in th:
		t.start()
		

---

线程同步 RLock()

• 同一时刻只允许一个线程操作共享资源。
• 共享资源块放在acquire() 与 release() 之间。
  类似java synchronized

improt threading
import time

class Test(threading.Thread):
	def run(self):
		global x
		lock.acquire()
		for i in range(4):
			x += 10
		time.sleep(1)
		print(x)
		lock.release()

x = 0
lock = threading.RLock()

if __name__ == '__main__':
	ths = []
	for i in range(5):
		ths.append(Test())
	for th in ths:
		th.start()

---

线程守护

• setDemo()
• join() 线程等待

---

th.setDemo(True)：

• 子线程变为主线程守护线程
• 主线程结束，子线程立马结束

if __name__ == '__main__':
	ths = []
	for i in range(4):
		ths.append(threading.Thread(target=doit, args=(2, 3))
	for th in ths:
		th.setDemo(True)
		th.start()
	print('End')

主线程运行完print('End')后，ths中的子线程不管完成与否都立马结束

---

th.join()：

• 线程等待
• 让主线程等待子线程执行完

if __name__ == '__main__':
	ths = []
	for i in range(4):
		ths.append(threading.Thread(target=doit, args=(2, 3))
	for th in ths:
		th.setDemo(True)
		th.start()
		th.join()
	print('End')

线程优先队列模块 queue

常用方法

常用方法	说明
qsize()	返回队列大小
empty()	判断队列是否为空
full()	判断队列是否满
get([block [, timeout]])	获取队列。 timeout：等待时间 block：与put相同
get_nowait()	get(False)
put(item[ ,block[ ,timeout]])	将item放入队列 timeout: 阻塞进程最长时间 block: False-队列有空间则放入数据，否则抛出Full异常   True&timeout为空----（默认）。阻塞调用，无超时
put_nowait(item)	put(item,False)
join()	等待队列为空（任务执行完），再执行别的操作。
task_done()	队列完成一项工作后，函数向该队列发送一个信号。

---

常用队列类型

• Queue 先入先出【队列】
• LifoQueue 后入先出【堆栈】
• PriorityQueue 优先级队列

---

以PriorityQueue为例

• 需要重写__lt__()方法，用于优先级判断

from threading import Thread, RLock
import queue
import time

# 继承 Thread 类
class Test(Thread):
	# 初始化，传入优先级
    def __init__(self, priority):
        super().__init__()
        self.pri = priority
        self.name = f'T_{self.pri}'
	
	# 重写，优先级判断依据
    def __lt__(self, th):
        return th.pri > self.pri

    def __str__(self):
        return f'\n线程：named-{self.pri}'
	
	# 重写 run() 方法
    def run(self):
        for i in range(8):
            print(f'{self.name}：__{self.pri * i}__', end='\t')
            time.sleep(.2)

# 新建 优先级队列
q = queue.PriorityQueue(maxsize=10)
lt = [3, 5, 1, 19, 4]
itm = []
for n in lt:
    q.put(Test(n))
while q.qsize():
    print(te := q.get(), ' Start')
    te.start()
    print('\n==============\n')