简说Python,号主老表,Python终身学习者,数据分析爱好者,从18年开始分享Python知识,原创文章227篇,写过Python、SQL、Excel入门文章,也写过Web开发、数据分析文章,老表还总结整理了一份2022Python学习资料和电子书资源,关注后私信回复:2022 即可领取。
1. 多任务简介
有很多的场景中的事情是同时进行的,比如开车的时候 手和脚共同来驾驶汽车,再比如唱歌跳舞也是同时进行的。
详细介绍可以查看参考链接:https://blog.csdn.net/weixin_42452337/article/details/93395692
1.1 程序中模拟多任务
import time def sing(): for i in range(3): print("正在唱歌...%d"%i) time.sleep(1) def dance(): for i in range(3): print("正在跳舞...%d"%i) time.sleep(1) if __name__ == '__main__': sing() dance()
2. 主线程和子线程的执行关系
- 主线程会等待子线程结束之后在结束
- join() 等待子线程结束之后,主线程继续执行
- setDaemon() 守护线程,不会等待子线程结束
import threading import time def demo(): # 子线程 print("hello girls") time.sleep(1) if __name__ == "__main__": for i in range(5): t = threading.Thread(target=demo) t.start()
运行结果:五个子线程都打印hello girls。
修改一下代码:
def demo(): for i in range(5): print('hello 子线程') time.sleep(1) if __name__ == '__main__': t = threading.Thread(target=demo) t.start() print('hello world!')
运行结果:
""" hello 子线程 hello world! hello 子线程 hello 子线程 hello 子线程 hello 子线程 """
那么问题来了:按照解释性语言的规则,print('hello world!')这句应该最后执行,但是运行结果不是这样的,所以主线程会在子线程结束之后结束。
但是看到程序运行的结果不是这样:我们需要调整。
2.1join()
方式一 t.join()等待子线程结束,再执行主线程 def demo(): for i in range(5): print('hello 子线程') time.sleep(1) if __name__ == '__main__': t = threading.Thread(target=demo) t.start() t.join() print('hello world!')
运行结果:
""" hello 子线程 hello 子线程 hello 子线程 hello 子线程 hello 子线程 hello world! """
2.2.setDaemon() 守护线程,不会等待子线程结束
def demo(): for i in range(5): print('hello 子线程') time.sleep(1) if __name__ == '__main__': t = threading.Thread(target=demo) t.setDaemon(True) t.start() print('hello world!')
运行结果如下:
# hello 子线程 # hello world!
3. 查看线程数量
threading.enumerate() 查看当前线程的数量
import threading import time def demo1(): for i in range(5): print('demo1--%s'%i) time.sleep(1) def demo2(): for i in range(10): print('demo2--%s'%i) time.sleep(1) def main(): t1 = threading.Thread(target=demo1) t2 = threading.Thread(target=demo2) t1.start() t2.start() while True: print(len(threading.enumerate())) if len(threading.enumerate()) <= 1: break time.sleep(1) if __name__ == '__main__': main()
运行结果如下:
demo1--0 demo2--0 3 demo2--1 3 demo1--1 demo2--2 3 demo1--2 demo2--3 3 demo1--3 demo2--4 demo1--4 3 demo2--5 2 demo2--6 2 demo2--7 2 demo2--8 2 demo2--9 2 1
可以看出:程序最终只有一个线程那就是主线程。
4. 验证子线程的执行与创建
当调用Thread的时候,不会创建线程。
当调用Thread创建出来的实例对象的start方法的时候,才会创建线程以及开始运行这个线程。
4.1继承Thread类创建线程
import threading import time class A(threading.Thread): def __init__(self,name): super().__init__(name=name) def run(self): for i in range(5): print(i) if __name__ == "__main__": t = A('test_name') t.start()
运行结果:
0 1 2 3 4
5. 线程间的通信(多线程共享全局变量)
在一个函数中,对全局变量进行修改的时候,是否要加global要看是否对全局变量的指向进行了修改,如果修改了指向,那么必须使用global,仅仅是修改了指向的空间中的数据,此时不用必须使用global。
线程是共享全局变量。
5.1 多线程参数-args
threading.Thread(target=test, args=(num,))
此处不做代码展示,下面的代码会展示。
6. 线程间的资源竞争
一个线程写入,一个线程读取,没问题,如果两个线程都写入呢?
import threading num = 0 def demo1(nums): global num for i in range(nums): num += 1 print('demo1==%s'%num) def demo2(nums): global num for i in range(nums): num += 1 print('demo2==%s'%num) def main(): t1 = threading.Thread(target=demo1,args=(1000000,)) t2 = threading.Thread(target=demo2,args=(1000000,)) t1.start() t2.start() if __name__ == '__main__': main()
运行结果:
demo2==1351678
demo1==1463250
这里我们会发现, 我们给两个函数传递的参数是1000000,每个函数都是进行100w次的+1操作, 按照我们的常识来说, 最后的结果应该是200w才对, 但是结果却是135168,1463250(这里的结果并不是固定的)。 产生这种结果的原因是因为python的解释器会把一个简单的+1操作分成多步:
1.获取num的值 2.将num的值+1 3.将运算完成的值赋给num
又因为这是多线程的, 所以cpu在处理两个线程的时候, 是采用雨露均沾的方式, 可能在线程一刚刚将num值+1还没来得及将新值赋给num时, 就开始处理线程二了, 因此当线程二执行完全部的num+=1的操作后, 可能又会开始对线程一的未完成的操作, 而此时的操作停留在了完成运算未赋值的那一步, 因此在完成对num的赋值后, 就会覆盖掉之前线程二对num的+1操作。
**解决方式:**就是接下来要提及的线程互斥锁.
import threading import time # 创建锁 mutex = threading.Lock() # 锁定 # 解锁 num = 0 def demo1(nums): global num for i in range(nums): mutex.acquire() num += 1 mutex.release() print('demo1==%s'%num) def demo2(nums): global num for i in range(nums): mutex.acquire() num += 1 mutex.release() print('demo2==%s'%num) def main(): t1 = threading.Thread(target=demo1,args=(1000000,)) t2 = threading.Thread(target=demo2,args=(1000000,)) t1.start() t2.start() if __name__ == '__main__': main()
demo1==1838868
demo2==2000000
7. 互斥锁和死锁
7.1 互斥锁
当多个线程几乎同时修改某一个共享数据的时候,需要进行同步控制。
某个线程要更改共享数据时,先将其锁定,此时资源的状态为"锁定",其他线程不能改变,只到该线程释放资源,将资源的状态变成"非锁定",其他的线程才能再次锁定该资源。互斥锁保证了每次只有一个线程进行写入操作,从而保证了多线程情况下数据的正确性。
创建锁 mutex = threading.Lock() 锁定 mutex.acquire() 解锁 mutex.release()
7.2 死锁
在线程间共享多个资源的时候,如果两个线程分别占有一部分资源并且同时等待对方的资源,就会造成死锁。
import threading import time class MyThread1(threading.Thread): def run(self): # 对mutexA上锁 mutexA.acquire() # mutexA上锁后,延时1秒,等待另外那个线程 把mutexB上锁 print(self.name+'----do1---up----') time.sleep(1) # 此时会堵塞,因为这个mutexB已经被另外的线程抢先上锁了 mutexB.acquire() print(self.name+'----do1---down----') mutexB.release() # 对mutexA解锁 mutexA.release() class MyThread2(threading.Thread): def run(self): # 对mutexB上锁 mutexB.acquire() # mutexB上锁后,延时1秒,等待另外那个线程 把mutexA上锁 print(self.name+'----do2---up----') time.sleep(1) # 此时会堵塞,因为这个mutexA已经被另外的线程抢先上锁了 mutexA.acquire() print(self.name+'----do2---down----') mutexA.release() # 对mutexB解锁 mutexB.release() mutexA = threading.Lock() mutexB = threading.Lock() if __name__ == '__main__': t1 = MyThread1() t2 = MyThread2() t1.start() t2.start()
7.3 避免死锁
- 程序设计时要尽量避免
- 添加超时时间等
8. Queue线程
在线程中,访问一些全局变量,加锁是一个经常的过程。如果你是想把一些数据存储到某个队列中,那么Python内置了一个线程安全的模块叫做queue模块。
Python中的queue模块中提供了同步的、线程安全的队列类,包括FIFO(先进先出)队列Queue,LIFO(后入先出)队列LifoQueue。这些队列都实现了锁原语(可以理解为原子操作,即要么不做,要么都做完),能够在多线程中直接使用。可以使用队列来实现线程间的同步。
初始化Queue(maxsize):创建一个先进先出的队列。 empty():判断队列是否为空。 full():判断队列是否满了。 get():从队列中取最后一个数据。 put():将一个数据放到队列中。
9. 线程同步
线程同步:即当有一个线程在对内存进行操作时,其他线程都不可以对这个内存地址进行操作,直到该线程完成操作, 其他线程才能对该内存地址进行操作,而其他线程又处于等待状态,实现线程同步的方法有很多,临界区对象就是其中一种。
天猫精灵:小爱同学 小爱同学:在 天猫精灵:现在几点了? 小爱同学:你猜猜现在几点了
由于线程同步问题信息过大感兴趣的可以看看这篇文章:http://blog.csdn.net/ebowtang/article/details/29905309
10. 生产者和消费者
生产者和消费者模式是多线程开发中常见的一种模式。通过生产者和消费者模式,可以让代码达到高内聚低耦合的目标,线程管理更加方便,程序分工更加明确。
生产者的线程专门用来生产一些数据,然后存放到容器中(中间变量)。消费者在从这个中间的容器中取出数据进行消费。
10.1 Lock版的生产者和消费者
import threading import random lock = threading.Lock() gmoney = 0 gTimes = 0 class Producer(threading.Thread): def run(self): global gmoney global gTimes while True: lock.acquire() money = random.randint(0,100) if gTimes >= 10: lock.release() break gmoney += money gTimes += 1 print("%s号消费者生产了%d元钱,有%d元钱"%(threading.current_thread().name,money,gmoney)) lock.release() class Comsumer(threading.Thread): def run(self): global gmoney global gTimes while True: lock.acquire() money = random.randint(0,100) if gmoney >= money: gmoney -= money print("%s号消费者消费了%d元钱,还剩%d元钱"%(threading.current_thread().name,money,gmoney)) else: if gTimes >= 10: lock.release() break print("%s号消费者需要消费了%d元钱,但是还剩%d元钱,余额不足"%(threading.current_thread().name,money,gmoney)) lock.release() def main(): for i in range(5): t1 = Producer(name="%s号生产者"%i) t1.start() for j in range(5): t2 = Comsumer(name="%s号消费者"%j) t2.start() if __name__ == '__main__': main()
运行结果:
0号生产者号消费者生产了18元钱,有18元钱 0号生产者号消费者生产了47元钱,有65元钱 0号生产者号消费者生产了52元钱,有117元钱 0号生产者号消费者生产了70元钱,有187元钱 0号生产者号消费者生产了28元钱,有215元钱 0号生产者号消费者生产了44元钱,有259元钱 0号生产者号消费者生产了2元钱,有261元钱 0号生产者号消费者生产了84元钱,有345元钱 0号生产者号消费者生产了43元钱,有388元钱 0号生产者号消费者生产了87元钱,有475元钱 0号消费者号消费者消费了70元钱,还剩405元钱 0号消费者号消费者消费了11元钱,还剩394元钱 0号消费者号消费者消费了78元钱,还剩316元钱 0号消费者号消费者消费了23元钱,还剩293元钱 0号消费者号消费者消费了46元钱,还剩247元钱 0号消费者号消费者消费了84元钱,还剩163元钱 0号消费者号消费者消费了16元钱,还剩147元钱 0号消费者号消费者消费了98元钱,还剩49元钱
10.2 Condition版的生产者和消费者
import threading import random gMoney = 0 # 定义一个变量 保存生产的次数 默认是0次 gTimes = 0 # 定义一把锁 # gLock = threading.Lock() gCond = threading.Condition() # 定义生产者 class Producer(threading.Thread): def run(self): global gMoney global gTimes while True: gCond.acquire() # 上锁 if gTimes >= 10: gCond.release() break money = random.randint(0,100) gMoney += money gTimes += 1 print("%s生产了%d元钱,剩余%d元钱" % (threading.current_thread().name, money, gMoney)) gCond.notify_all() gCond.release() # 解锁 # 定义消费者 class Consumer(threading.Thread): def run(self): global gMoney while True: gCond.acquire() # 上锁 money = random.randint(0, 100) while gMoney < money: if gTimes >= 10: gCond.release() return # 这里如果用break只能退出外层循环,所以我们直接return print("%s想消费%d元钱,但是余额只有%d元钱了,并且生产者已经不再生产了!"%(threading.current_thread().name,money,gMoney)) gCond.wait() # 开始消费 gMoney -= money print("%s消费了%d元钱,剩余%d元钱" % (threading.current_thread().name, money, gMoney)) gCond.release() def main(): # 开启5个生产者线程 for x in range(5): th = Producer(name="生产者%d号" % x) th.start() # 开启5个消费者线程 for x in range(5): th = Consumer(name="消费者%d号" % x) th.start() if __name__ == '__main__': main()
运行结果:
生产者0号生产了26元钱,剩余26元钱 生产者0号生产了99元钱,剩余125元钱 生产者0号生产了37元钱,剩余162元钱 生产者0号生产了77元钱,剩余239元钱 生产者0号生产了3元钱,剩余242元钱 生产者0号生产了91元钱,剩余333元钱 生产者0号生产了51元钱,剩余384元钱 生产者0号生产了66元钱,剩余450元钱 生产者0号生产了43元钱,剩余493元钱 生产者2号生产了79元钱,剩余572元钱 消费者0号消费了70元钱,剩余502元钱 消费者0号消费了25元钱,剩余477元钱 消费者0号消费了47元钱,剩余430元钱 消费者0号消费了74元钱,剩余356元钱 消费者1号消费了12元钱,剩余344元钱 消费者2号消费了33元钱,剩余311元钱 消费者0号消费了89元钱,剩余222元钱 消费者0号消费了90元钱,剩余132元钱 消费者0号消费了54元钱,剩余78元钱 消费者4号消费了57元钱,剩余21元钱