多任务

有很多的场景中的事情是同时进行的，比如开车的时候 手和脚共同来驾驶汽车，再比如唱歌跳舞也是同时进行的
在程序中模拟多任务：

import timedef 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 timedef 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 threadingdef 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 threadingclass 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 timenum = 100def demo1():global numnum += 1print("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 timenum = 0def demo1(nums):global numfor i in range(nums):num += 1print('demo1---num:%d' % num)def demo2(nums):global numfor i in range(nums):num += 1print('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 timenum = 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 timeclass 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 threadingclass Xiaoai(threading.Thread):def __init__(self, cond):super().__init__()self.cond = conddef 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 = conddef 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 threadingdef 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()