多任务
有很多的场景中的事情是同时进行的,比如开车的时候 手和脚共同来驾驶汽车,再比如唱歌跳舞也是同时进行的
在程序中模拟多任务:
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()
在运行的上述代码中,其实并不是真正意义的多任务,因为他完成的是先把唱歌唱完了,再跳舞,而不是两个一起完成。
在计算机中的多任务我们可以理解为,同时运行着qq,qq音乐,英雄联盟等。
计算机执行多任务的方式可以分为并行、并发两种:
并行:真的多任务 cpu大于当前执行的任务
并发:假的多任务 cpu小于当前执行的任务
那么我们应该怎么在代码中实现多任务呢?
线程完成多任务
import threading
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)
def main():
t1 = threading.Thread(target=sing)
t2 = threading.Thread(target=dance)
t1.start()
t2.start()
if __name__ == '__main__':
main()
使用线程我们导入threading模块,并使用其中的Thread方法创建线程,target为指向。
如果加上:t.setDaemon(True) 为守护线程 不会等子线程结束
如果加上t.join()为等待子线程执行结束 主线程继续执行
验证子线程的执行与创建
threading.enumerate() 查看当前线程的数量
import time
import threading
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__':
print(threading.enumerate())
t1 = threading.Thread(target=sing)
t2 = threading.Thread(target=dance)
print(threading.enumerate())
t1.start()
print(threading.enumerate())
t2.start()
print(threading.enumerate())
当调用Thread的时候,不会创建线程。
当调用Thread创建出来的实例对象的start方法的时候,才会创建线程以及开始运行这个线程。
所以四次打印出来的结果会是一个,一个,两个,三个。
主线程会等到子线程执行结果之后主线程 才会结束。
继承Thread类创建线程
import threading
class A(threading.Thread):
def __init__(self):
super().__init__()
def run(self):
for i in range(5):
print(i)
if __name__ == '__main__':
t = A()
t.start()
继承Thread类创建线程时需注意的是需要再类里添加run方法,而线程开始执行使用的还是t.start()。
多线程共享全局变量(线程间通信)
import threading
import time
num = 100
def demo1():
global num
num += 1
print("demo1---%d" % num)
def demo2():
print("demo2---%d" % num)
def main():
t1 = threading.Thread(target=demo1)
t2 = threading.Thread(target=demo2)
t1.start()
# time.sleep(1)
t2.start()
# time.sleep(1)
print("main---%d" % num)
if __name__ == '__main__':
main()
三次打印出的结果都是101,可见多线程是共享全局变量的。
多线程参数-args
当多线程需要传入参数时,我们可以通过threading.Thread(target=test, args=(num,))这样的形式来传入参数。
共享全局变量资源竞争
一个线程写入,一个线程读取,没问题,但是如果两个线程都写入呢?
import threading
import time
num = 0
def demo1(nums):
global num
for i in range(nums):
num += 1
print('demo1---num:%d' % num)
def demo2(nums):
global num
for i in range(nums):
num += 1
print('demo2--num:%d' % num)
def main():
t1 = threading.Thread(target=demo1, args=(1000000,))
t2 = threading.Thread(target=demo2, args=(1000000,))
t1.start()
t2.start()
print("main----num:%d" % num)
if __name__ == '__main__':
main()
如这种情况我们会发现打印出来的结果并不准确。
这时我们可以使用互斥锁:
当多个线程几乎同时修改某一个共享数据的时候,需要进行同步控制
某个线程要更改共享数据时,先将其锁定,此时资源的状态为"锁定",其他线程不能改变,只到该线程释放资源,将资源的状态变成"非锁定",其他的线程才能再次锁定该资源。互斥锁保证了每次只有一个线程进行写入操作,从而保证了多线程情况下数据的正确性。
import threading
import time
num = 0
# 创建一个互斥锁,默认是没有上锁的
mutex = threading.Lock()
def demo1(nums):
global num
# 加锁
mutex.acquire()
for i in range(nums):
num += 1
# 解锁
mutex.release()
print('demo1---num:%d' % num)
def demo2(nums):
global num
# 加锁
mutex.acquire()
for i in range(nums):
num += 1
# 解锁
mutex.release()
print('demo2--num:%d' % num)
def main():
t1 = threading.Thread(target=demo1, args=(100000,))
t2 = threading.Thread(target=demo2, args=(100000,))
t1.start()
t2.start()
time.sleep(2)
print("main----num:%d" % num)
if __name__ == '__main__':
main()
如果使用的是RLock,则为可重入的锁。
再现在start后还需加入一个time.sleep的原因为数据过大的话,还需给他一点时间缓一下,不然线程还没执行完,就执行到打印部分了。
死锁
在线程间共享多个资源的时候,如果两个线程分别占有一部分资源并且同时等待对方的资源,就会造成死锁。
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()
遇到这种情况,程序便会堵塞无法继续。
为了避免死锁:
程序设计时要尽量避免
添加超时时间等。
线程同步
当我们需要解决
天猫精灵:天猫精灵你好呀
小爱同学:你好呀
天猫精灵:今天天气怎么样了啊
小爱同学:还可以哟
这样一个功能时,我们会发现仅用到锁是不够的,这时我们应该使用threading中的条件变量同步Condition
import threading
class Xiaoai(threading.Thread):
def __init__(self, cond):
super().__init__()
self.cond = cond
def run(self):
self.cond.acquire()
print("小爱同学:天猫精灵你好呀")
self.cond.notify()
self.cond.wait()
print("小爱同学:今天天气怎么样了啊")
self.cond.notify()
self.cond.release()
class Tianmao(threading.Thread):
def __init__(self, cond):
super().__init__()
self.cond = cond
def run(self):
self.cond.acquire()
self.cond.wait()
print("天猫精灵:你好呀")
self.cond.notify()
self.cond.wait()
print("天猫精灵:还可以哟")
self.cond.release()
def main():
cond = threading.Condition()
xiaoai = Xiaoai(cond)
tianmao = Tianmao(cond)
tianmao.start()
xiaoai.start()
if __name__ == '__main__':
main()
Condition中使用到的wait()和notify()方法的意思可以理解为是沉睡,唤醒,当需要这个线程先停止运行另一边线程时便是这边的先wait()沉睡了,再notify()唤醒另一边的。
值得注意的是类的__init__方法中必须添加super().__init__()这样对父级__init__方法的描述,不然就会出现raise RuntimeError(“thread.init() not called”)的报错。
多线程的udp聊天器
实现这个功能就是将线程与socket相结合,大致思路为:
1 创建套接字
2 绑定本地信息
3 获取对方IP和端口
4 发送、接收数据
5 创建两个线程,去执行功能
import socket
import threading
def recv_msg(udp_socket):
"""发送数据"""
while True:
recv_data = udp_socket.recvfrom(1024)
print(recv_data)
def send_msg(udp_socket, dest_ip, dest_port):
"""接收数据"""
while True:
send_data = input("输入要发送的数据:")
udp_socket.sendto(send_data.encode('gbk'), (dest_ip, dest_port))
def main():
"""完成udp聊天器"""
# 创建套接字
udp_socket = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
# 绑定
udp_socket.bind(("", 8080))
# 获取对方的IP和端口
dest_ip = input('请输入对方的IP:')
dest_port = int(input('请输入对方的port:'))
t_recv = threading.Thread(target=recv_msg, args=(udp_socket,))
t_send = threading.Thread(target=send_msg, args=(udp_socket, dest_ip, dest_port))
t_recv.start()
t_send.start()
if __name__ == '__main__':
main()