Python3——多线程之threading模块 - 好文

Python3——多线程之threading模块

目录

Python3——多线程之threading模块
<https://blog.csdn.net/a1314521531/article/details/82754617#Python3%E2%80%94%E2%80%94%E5%A4%9A%E7%BA%BF%E7%A8%8B%E4%B9%8Bthreading%E6%A8%A1%E5%9D%97>

Threading模块的对象
<https://blog.csdn.net/a1314521531/article/details/82754617#Threading%E6%A8%A1%E5%9D%97%E7%9A%84%E5%AF%B9%E8%B1%A1>

Threading模块的Thread类
<https://blog.csdn.net/a1314521531/article/details/82754617#Threading%E6%A8%A1%E5%9D%97%E7%9A%84Thread%E7%B1%BB>

queue模块（线程间通信）
<https://blog.csdn.net/a1314521531/article/details/82754617#queue%E6%A8%A1%E5%9D%97%EF%BC%88%E7%BA%BF%E7%A8%8B%E9%97%B4%E9%80%9A%E4%BF%A1%EF%BC%89>

Python 提供了多个模块来支持多线程编程，包括 thread、 threading 和 Queue 模块等。程序是可以使用 thread 和
threading 模块来创建与管理线程。 thread 模块提供了基本的线程和锁定支持；而 threading
模块提供了更高级别、功能更全面的线程管理。使用 Queue
模块，用户可以创建一个队列数据结构，用于在多线程之间进行共享。（推荐使用threading模块比thread模块更高级）

*
Threading模块的对象

对象

描述

Thread

线程对象

Lock

互斥锁

Condition

条件变量

Event

事件，该事件发生后所有等待该事件的线程将激活

Semaphore

信号量（计数器）

Timer

定时器，运行前会等待一段时间

Barrier

创建一个障碍，必须达到指定数量线程才开始运行

*
Threading模块的Thread类

对象

描述

name

线程名（属性）

ident

线程标识符（属性）

daemon

线程是否是守护线程（属性）

_init_(group=None, tatget=None, name=None, args=(),kwargs ={}, verbose=None,
daemon=None)

实例化一个线程对象，需要有一个可调用的 target，以及其参数 args或 kwargs。还可以传递 name 或 group
参数，不过后者还未实现。此外， verbose 标志也是可接受的。而 daemon 的值将会设定thread.daemon 属性/标志

start()

开启线程

run()

定义线程功能的方法（通常在子类中被应用开发者重写）

Barrier

创建一个障碍，必须达到指定数量线程才开始运行
import threading from time import ctime, sleep loops = (3, 2) class
Mythread(threading.Thread): def __init__(self, func, args, name=''):
threading.Thread.__init__(self) self.name = name self.func = func self.args =
args ''' rewrite run() ''' def run(self): self.func(*self.args) ''' thread
handle func --- while(1) ''' def loop(nloop, nsec): while True: print('start
loop ' + str(nloop), 'at: ' + str(ctime())) sleep(nsec) def main(): threads =
[] nloops = range(len(loops)) for i in nloops: t = Mythread(loop, (i + 1,
loops[i]), loop.__name__) threads.append(t) for i in nloops: threads[i].start()
if __name__ == '__main__': main()

*
queue模块（线程间通信）

Queue(maxsize = 0)

创建一个先入先出队列。如果给定最大值，则在队列没有空间时阻塞；否则（没有指定最大值），为无限队列

LifoQueue(maxsize=0)

创建一个后入先出队列。如果给定最大值，则在队列没有空间时阻塞;否则（没有指定最大值），为无限队列

PriorityQueue(maxsize=0)

创建一个优先级队列。如果给定最大值，则在队列没有空间时阻塞，否则（没有指定最大值），为无限队列

Empty

当对空队列调用 get*()方法时抛出异常

Full

当对已满的队列调用 put*()方法时抛出异常

qsize ()

返回队列大小

empty()

如果队列为空，则返回 True；否则，返回 False

full()

如果队列已满，则返回 True；否则，返回 False

put (item, block=Ture, timeout=None)

将 item 放入队列。如果 block 为 True（默认）且 timeout 为 None，则在有可用空间之前阻塞；如果 timeout
为正值，则最多阻塞 timeout 秒；如果 block 为 False，则抛出 Empty 异常

get (block=True, timeout=None)

从队列中取得元素。如果给定了 block（非 0），则一直阻塞到有可用的元素为止

join()

在队列中所有元素执行完毕并调用上面的 task_done()信号之前，保持阻塞
import threading from random import randint from queue import * from time
import ctime, sleep class Mythread(threading.Thread): def __init__(self, func,
name=''): threading.Thread.__init__(self) self.name = name self.func = func '''
rewrite run() ''' def run(self): self.func() class MyQueue(): def
__init__(self, q, loops): self.q = q self.loops = loops def WriteQueue(self):
self.q.put('xxx', 1) def ReadQueue(self): value = self.q.get(1) print('value: '
+ str(value)) return value def Writer(self): while 1: for i in
range(self.loops): self.WriteQueue() def Reader(self): while 1: for i in
range(self.loops): aaa = self.ReadQueue() print("aaa = " + str(aaa)) def
main(): que = Queue(32) nloops = randint(2, 5) q = MyQueue(que, nloops) t1 =
Mythread(q.Writer, q.Writer.__name__) t2 = Mythread(q.Reader,
q.Reader.__name__) t1.start() t2.start() if __name__ == '__main__': main()

热门工具换一换