多线程:
参考博客:
https://blog.csdn.net/somezz/article/details/80963760
https://www.cnblogs.com/hiwuchong/p/8673183.html
Python3 线程中常用的两个模块为：
- _thread
提供了低级别的, 原始的线程以及一个简单的锁, 反正就是线程的手动低级控制 - threading(推荐使用)
包含了_thread模块的所有方法, 并对这些方法进行了封装, 提供更高级别, 功能更强, 易于使用的线程管理功能- threading.currentThread(): 返回当前的线程变量.
- threading.enumerate(): 返回一个包含正在运行的线程的list. 正在运行指线程启动后、结束前, 不包括启动前和终止后的线程.
- threading.activeCount(): 返回正在运行的线程数量, 与 len(threading.enumerate()) 有相同的结果.
thread 模块已被废弃. 用户可以使用 threading 模块代替. 所以, 在 Python3 中不能再使用"thread" 模块. 为了兼容性, Python3 将 thread 重命名为 “_thread”.
除了使用方法外, threading模块同样提供了 Thread 类来处理线程, Thread 类提供了以下方法:
-
run():
用以表示线程活动的方法. -
start():
启动线程活动.
-
join([time]):
等待至线程中止. 这阻塞调用线程直至线程的 join() 方法被调用中止-正常退出或者抛出未处理的异常-或者是可选的超时发生. -
isAlive():
返回线程是否活动的. -
getName():
返回线程名. -
setName():
设置线程名.
一个例子:
使用最简单的方法开了俩线程, 不断的执行print_time函数
主线程在while 中不断循环(主线程一旦终止, 其余线程也结束)
import _thread
import time
# 为线程定义一个函数
def print_time( threadName, delay):
count = 0
while count < 5:
time.sleep(delay)
count += 1
print ("%s: %s" % ( threadName, time.ctime(time.time()) ))
# 创建两个线程
try:
_thread.start_new_thread( print_time, ("Thread-1", 2, ) )
_thread.start_new_thread( print_time, ("Thread-2", 4, ) )
except:
print ("Error: 无法启动线程")
while 1:
pass
输出:
需要手动ctrl-c退出
Thread-1: Sat Jan 9 17:16:33 2021
Thread-2: Sat Jan 9 17:16:35 2021
Thread-1: Sat Jan 9 17:16:35 2021
Thread-1: Sat Jan 9 17:16:37 2021
Thread-2: Sat Jan 9 17:16:39 2021
Thread-1: Sat Jan 9 17:16:39 2021
threading 创建进程:
基本上是利用threading.Thread类:
可以直接将任务传递给Thread类, 以构造一个Thread实例:
import time
import threading
def task_thread(counter):
print(f'线程名称：{threading.current_thread().name} 参数：{counter} 开始时间：{time.strftime("%Y-%m-%d %H:%M:%S")}')
num = counter
while num:
time.sleep(3)
num -= 1
print(f'线程名称：{threading.current_thread().name} 参数：{counter} 结束时间：{time.strftime("%Y-%m-%d %H:%M:%S")}')
if __name__ == '__main__':
print(f'主线程开始时间：{time.strftime("%Y-%m-%d %H:%M:%S")}')
#初始化3个线程，传递不同的参数
t1 = threading.Thread(target=task_thread, args=(3,))
t2 = threading.Thread(target=task_thread, args=(2,))
t3 = threading.Thread(target=task_thread, args=(1,))
#开启三个线程
t1.start()
t2.start()
t3.start()
#等待运行结束
t1.join()
t2.join()
t3.join()
print(f'主线程结束时间：{time.strftime("%Y-%m-%d %H:%M:%S")}')
或是自建一个class继承Thread类:
#初始化3个线程，传递不同的参数
t1 = threading.Thread(target=task_thread, args=(3,))
t2 = threading.Thread(target=task_thread, args=(2,))
t3 = threading.Thread(target=task_thread, args=(1,))
class myThread (threading.Thread):
def __init__(self, threadID, name, counter):
threading.Thread.__init__(self)
self.threadID = threadID
self.name = name
self.counter = counter
def run(self):
print ("开始线程：" + self.name)
print_time(self.name, self.counter, 5)
print ("退出线程：" + self.name)
这里用到了基类的数据成员:
并且注意需要重载run()方法, 在线程start()后会自动调用
如果需要调用外部传入的函数, 需要在__init()__ 中添加参数并在run()中引用:
def task_thread(counter):
print(f'线程名称：{threading.current_thread().name} 参数：{counter} 开始时间：{time.strftime("%Y-%m-%d %H:%M:%S")}')
num = counter
while num:
time.sleep(3)
num -= 1
print(f'线程名称：{threading.current_thread().name} 参数：{counter} 结束时间：{time.strftime("%Y-%m-%d %H:%M:%S")}')
class MyThread(threading.Thread):
def __init__(self, target, args):
super().__init__()
self.target = target
self.args = args
def run(self):
self.target(*self.args)
-
args的作用是可变参数, 用于传递给target
详见之前的函数章节
常用的函数也就是上头的那些:
-
start()
开始执行线程
但线程的实际开始时间由python控制, 与代码执行顺序并不相同
-
join()
相当于线程同步, 在线程B中调用线程A的join()方法, 会使得线程B与线程A进行同步
线程B将会在join()处等待线程A退出 (正常退出或者抛出未处理的异常-或者是可选的超时发生)这部分将在线程同步中详细解释
-
isAlive():
返回线程是否活动的. -
getName():
返回线程名. -
setName():
设置线程名. -
run():
用以表示线程活动的方法.一般会在自建Thread类中重写该方法
所以如果直接调用的话, 会在主线程中执行run()方法, 并没有实现多线程
线程同步:
join():
例子:
import time
import threading
class MyThread(threading.Thread):
def __init__(self, counter):
super().__init__()
self.counter = counter
def run(self):
print(
f'线程名称：{threading.current_thread().name} 参数：{self.counter} 开始时间：{time.strftime("%Y-%m-%d %H:%M:%S")}'
)
counter = self.counter
while counter:
time.sleep(3)
counter -= 1
print(
f'线程名称：{threading.current_thread().name} 参数：{self.counter} 结束时间：{time.strftime("%Y-%m-%d %H:%M:%S")}'
)
if __name__ == "__main__":
print(f'主线程开始时间：{time.strftime("%Y-%m-%d %H:%M:%S")}')
# 初始化3个线程，传递不同的参数
t1 = MyThread(3)
t2 = MyThread(2)
t3 = MyThread(1)
# 开启三个线程
t1.start()
# print("WDNMD", t1.run())
t2.start()
t3.start()
# 等待运行结束
t1.join()
t2.join()
t3.join()
t1.run()
print(f'主线程结束时间：{time.strftime("%Y-%m-%d %H:%M:%S")}')
输出:
主线程开始时间：2021-01-10 10:29:04
线程名称：Thread-1 参数：3 开始时间：2021-01-10 10:29:04
线程名称：Thread-2 参数：2 开始时间：2021-01-10 10:29:04
线程名称：Thread-3 参数：1 开始时间：2021-01-10 10:29:04
线程名称：Thread-3 参数：1 结束时间：2021-01-10 10:29:07
线程名称：Thread-2 参数：2 结束时间：2021-01-10 10:29:10
线程名称：Thread-1 参数：3 结束时间：2021-01-10 10:29:13
线程名称：MainThread 参数：3 开始时间：2021-01-10 10:29:13
线程名称：MainThread 参数：3 结束时间：2021-01-10 10:29:22
主线程结束时间：2021-01-10 10:29:22
可以看到:
- 执行join()后, 主线程在等待3个子线程的执行结束
- 直接执行t1.run() 后, 并没有开启多线程, 而是在MainThread主线程中执行run()函数
互斥锁 Lock & RLock:
- threading.Lock()
获得的是标准的互斥锁, 每次只能锁一次, 其余的锁请求需要等待锁释放才能获取 - threading.RLock()
获得的是可重入的互斥锁, 在同一个线程中可以对其进行多次锁定, 但解锁与开锁必须成对出现
使用:
lock = threading.Lock() # 获取一个锁对象
lock.acquire() # 加锁
lock.release() # 去锁
同一个锁对象只能加锁一次, 利用这个规则可以实现:
import time
import threading
num = 0
lock = threading.Lock()
def task_thread(n):
global num
# 获取锁，用于线程同步
lock.acquire()
for i in range(1000000):
num = num + n
num = num - n
#释放锁，开启下一个线程
lock.release()
if __name__ == "__main__":
t1 = threading.Thread(target=task_thread, args=(6, ))
t2 = threading.Thread(target=task_thread, args=(17, ))
t3 = threading.Thread(target=task_thread, args=(11, ))
t1.start()
t2.start()
t3.start()
t1.join()
t2.join()
t3.join()
print(num)
正确的输出结果为0 , 如果不加锁的话输出非0
而对于RLock:
if __name__ == "__main__":
lock = threading.RLock()
lock.acquire()
print(lock)
lock.acquire()
print(lock)
lock.release()
print(lock)
lock.release()
print(lock)
信号量 Semaphore:
操作系统里都讲过了, 直接上代码:
import threading
import time
# 同时只有5个人办理业务
semaphore = threading.BoundedSemaphore(5) # 获得一个限量为5的信号量
# 模拟银行业务办理
def yewubanli(name):
semaphore.acquire() # 与Lock相似, 也是使用acquire() & release() 进行信号量的申请&释放
time.sleep(3)
print(f"{time.strftime('%Y-%m-%d %H:%M:%S')} {name} 正在办理业务")
semaphore.release()
thread_list = []
for i in range(12):
t = threading.Thread(target=yewubanli, args=(i,))
thread_list.append(t)
for thread in thread_list:
thread.start()
for thread in thread_list:
thread.join()
条件变量 Condition:
参考博客:
https://blog.csdn.net/ckk727/article/details/99950843
互斥锁Lock和RLock只能提供简单的加锁和释放锁等功能，它们的主要作用是在多线程访问共享数据时，保护共享数据，防止数据被脏读脏写，保证数据和关键代码的完整性。
在此基础上，Python提供了Condition类，Condition类不仅自身依赖于Lock和RLock，即具有它们的阻塞特性，此外还提供了一些有利于线程通信，以及解决复杂线程同步问题的方法，它也被称作条件变量。
就是比常规的锁多了这些高级方法
构造方法：
__init__(self,lock=None)
1）从Condition类的构造方法可以看出，Condition类总是与一个锁相关联。在创建一个Condition类的同时就应该传入Condition类需要绑定的Lock对象；
2）另外，如果不指定lock参数，那么Python会自动创建一个与之绑定的Lock对象。
acquire(timeout)
调用Condition类关联的Lock/RLock的acquire()方法。
release()
调用Condition类关联的Lock/RLock的release()方法。
wait(timeout)
1）线程挂起，直到收到一个notify通知或者等待时间超出timeout才会被唤醒；
2）注意：wait()必须在已获得Lock的前提下调用，否则会引起RuntimeError错误。
notify(n=1)
1）唤醒在Condition的waiting池中的n（参数n可设置，默认为1）个正在等待的线程并通知它，受到通知的线程将自动调用acquire()方法尝试加锁；
2）如果waiting池中有多个线程，随机选择n个唤醒；
3）必须在已获得Lock的前提下调用，否则将引发错误。
notify_all()
唤醒waiting池中的等待的所有线程并通知它们。
生产者 & 消费者 问题:
import threading
from time import sleep
#商品
product = 500
#条件变量
con = threading.Condition(threading.Lock())
#生产者类
#继承Thread类
class Producer(threading.Thread):
def __init__(self, name):
super().__init__()
self.name = name
def run(self):
global product
while True:
#如果获得了锁
if con.acquire():
#处理产品大于等于500和小于500的情况
if product >= 500:
#如果大于等于500，Producer不需要额外操作，于是挂起
con.wait()
else:
product += 50
message = self.name + " produced 50 products."
print(message)
#处理完成，发出通知告诉Consumer
con.notify()
#释放锁
con.release()
sleep(1)
#消费者类
#继承Thread类
class Consumer(threading.Thread):
def __init__(self, name):
super().__init__()
self.name = name
def run(self):
global product
while True:
#如果获得了锁
if con.acquire():
#处理product小于等于100和大于100的两种情况
if product <= 100:
#如果小于等于100，Consumer不需要额外操作，于是挂起
con.wait()
else:
product -= 10
message = self.name + " consumed 10 products."
print(message)
#处理完成，发出通知告诉Producer
con.notify()
#释放锁
con.release()
sleep(1)
def main():
#创建两个Producer
for i in range(2):
p = Producer('Producer-%d' % i)
p.start()
#创建三个Consumer
for i in range(3):
c = Consumer('Consumer-%d' % i)
c.start()
if __name__ == '__main__':
main()
Event:
参考博客:
https://www.cnblogs.com/zhangshengxiang/p/9606133.html
同进程的一样,线程的一个关键特性是每个线程都是独立运行且状态不可预测。如果程序中的其 他线程需要通过判断某个线程的状态来确定自己下一步的操作,这时线程同步问题就会变得非常棘手。为了解决这些问题,我们需要使用threading库中的Event对象。 对象包含一个可由线程设置的信号标志,它允许线程等待某些事件的发生。在 初始情况下,Event对象中的信号标志被设置为假。如果有线程等待一个Event对象, 而这个Event对象的标志为假,那么这个线程将会被一直阻塞直至该标志为真。一个线程如果将一个Event对象的信号标志设置为真,它将唤醒所有等待这个Event对象的线程。如果一个线程等待一个已经被设置为真的Event对象,那么它将忽略这个事件, 继续执行
总结:
Event的功能上更加简单, 有点像是Condition的缩水版, 相当于一个所有线程都可以访问的Flag, 创建时默认为False, 此时调用event.wait() 的线程会进入等待状态, 如果有一个线程将Event设置为True, 则所有等待Event的线程都会被唤醒
Event几种方法:
-
event.isSet()：返回event的状态值；
-
event.wait()：如果 event.isSet()==False将阻塞线程；
-
event.set()： 设置event的状态值为True，所有阻塞池的线程激活进入就绪状态， 等待操作系统调度；
-
event.clear()：恢复event的状态值为False。
线程优先级队列:
参考博客:
https://blog.csdn.net/alian_w/article/details/104426974
这个是利用Python 内置的Queue模块实现的:
q = Queue(maxsize=)
q = Queue()
# maxsize=:表示队列大小最大值，当队列到达最大值时再插入则线程会挂起
# 可不填，不填则理论无上限
利用这个特性可以很轻松的实现 生产者 & 消费者 模型
import threading,time
import queue
#先进先出
q = queue.Queue(maxsize=5)
def ProducerA():
count = 1
while True:
q.put(f"冷饮 {count}")
print(f"A 放入:[冷饮 {count}]")
count +=1
time.sleep(1)
def ConsumerB():
while True:
print(f"B 取出 [{q.get()}]")
time.sleep(5)
p = threading.Thread(target=ProducerA)
c = threading.Thread(target=ConsumerB)
c.start()
p.start()
输出:
16:29:19 A 放入:[冷饮 1]
16:29:19 B 取出 [冷饮 1]
16:29:20 A 放入:[冷饮 2]
16:29:21 A 放入:[冷饮 3]
16:29:22 A 放入:[冷饮 4]
16:29:23 A 放入:[冷饮 5]
16:29:24 B 取出 [冷饮 2]
16:29:24 A 放入:[冷饮 6]
16:29:25 A 放入:[冷饮 7]
16:29:29 B 取出 [冷饮 3]
16:29:29 A 放入:[冷饮 8]
16:29:34 B 取出 [冷饮 4]
16:29:34 A 放入:[冷饮 9]
进程池 & 线程池:
这部分算高级应用了, 有需要在看
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
