一、为什么要有多任务？
平时唱歌跳舞都是一起进行的，如果先唱歌后跳舞，或者先跳舞后唱歌，感觉很不协调，别扭—所以需要一个多任务
案例：
from time import sleep def sing(): for i in range(3): print("正在唱歌....%d"%i) sleep(1) def dance(): for i in range(3): print("正在跳舞....%d"%i) sleep(1) if __name__ == '__main__': sing() dance()
二、多任务介绍
概念：多任务就是可以一边听歌，一边上网冲浪，或者在干点其它什么的，可以同时有2个以上的任务在执行
注意：
并发：某个时间段内，多个任务交替执行。当有多个线程在操作时，把CPU运行时间划分成若干个时间段，再将时间段分配给各个线程执行，在一个时间段的线程代码运行时，其它线程处于挂起状态(暂停)。
并行：同一时间处理多任务的能力，多有多个线程在操作时，CPU同时处理这些线程请求的能力。
三、threading介绍
Python的thread模块是比较底层的，Python的threading模块是对thread做了包装，使用更加方便。
threading常用方法：
方法名 解释
threading.active_count() 返回当前处于active状态的Thread对象
threading.current_thread() 返回当前Thread对象
threading.get_ident() 返回当前线程的线程标识符，线程标识符是一个非负整数，并无特殊含义，知识用来标识线程，该证书可能会被循环利用。Python3.3版本后支持该方法
threading.enumerate() 返回当前处于active解释器的线程对象。Python3.4版本以后支持该方法
threading.main_thread() 返回主线程对象，即启动Python解释器的线程对象。Python3.4版本以后支持该方法
threading.stack_size() 返回创建线程时使用的栈的大小，如果指定size参数，则用来指定后续创建的线程使用的栈大小，size必须是0(标识使用系统默认值)或大于32K正整数
1、Thread类使用说明
threading模块提供了Thread、Lock、RLock、Conditon、Event、Timer和Semaphore等类来支持多线程，Thread是其中最重要也是最基本的一个类，通过该类创建线程并控制线程的运行。
使用Thread创建线程的方法：
- 为构造函数传递一个可调用对象
- 集成Thread类并在子类中重写__init__()和run()方法
- 语法格式：threading.Thread(group=None,target=None,name=None,args=(),kwargs={},*,daemon=None)
- 参数说明：
- group：通常默认即可，作为日后扩展ThreadGroup类实现而保留。
- target：用于run()方法调用的可调用对象，默认为None
- name：线程名，默认是Thread-N格式构成唯一名称，N是十进制数(正整数)
- args：用于调用目标函数的关键字参数字典，默认为{}
- daemon：设置线程是否为守护模式，默认None
threading.Thread的方法和属性：
|方法名 | 解释 |
|–|–|
| start() | 启动线程 |
|run()|线程代码，用来实现线程的功能与业务逻辑，可以在子类中重写该方法来自定义线程的行为|
|init(self,group=None,target=None,name=None,args=(),kwargs=None,daemon=None)|构造函数|
|is_alive()|判断线程是否存活|
|getName()|返回线程名|
|setName()|设置线程名|
|isDaemon()|判断线程是否为守护线程|
|setDaemon()|设置线程是否为守护线程|
|name|用来读取或设置线程的名字|
|ident|线程标识，用非0数字或None(线程未被启动)|
|daemon|线程是否为守护线程，默认false|
|join(timeout=None)|当timeout=None时，会等待至线程结束；当非None时，会等待timeout时间结束，单位秒|
2、实例化threading.Thread(重点)
1）单线程执行 --时间间隔
from time import sleep import datetime def sing(): print("正在唱歌....") sleep(1) if __name__ == '__main__': for i in range(3): sing() print(datetime.datetime.now())
2）使用threading模块
import threading from time import sleep import datetime def sing(): print("正在唱歌....") sleep(1) if __name__ == '__main__': for i in range(3): t = threading.Thread(target=sing) t.start() print(datetime.datetime.now())
看执行速度能对比出来threading多线程速度飞快
调用start()才会创建真正的多线程，开始执行代码
3）主线程等待所有子线程结束后才结束
import threading from time import sleep, ctime def sing(): for i in range(3): print("正在唱歌....%d" % i) sleep(1) def dance(): for i in range(3): print("正在跳舞....%d" % i) sleep(1) if __name__ == '__main__': print("开始：", ctime()) t1 = threading.Thread(target=sing) t2 = threading.Thread(target=dance) t1.start() t2.start() print("结束: ", ctime())
4）查看线程数
import threading from time import sleep, ctime def sing(): for i in range(3): print("正在唱歌....%d" % i) sleep(1) def dance(): for i in range(3): print("正在跳舞....%d" % i) sleep(1) if __name__ == '__main__': print("开始：", ctime()) t1 = threading.Thread(target=sing) t2 = threading.Thread(target=dance) t1.start() t2.start() while True: num = len(threading.enumerate()) print("线程数： %d" % num) if (num) < 1: break sleep(1) print("结束: ", ctime())
四、继承threading.Thread
1、线程执行封装代码
使用threading线程模块封装时，定义一个新的子类class，继承threading.Thread，重写run方法
import threading from time import sleep class MyClass(threading.Thread): def run(self): for i in range(3): sleep(1) msg = self.name + "--->" + str(i) print(msg) if __name__ == '__main__': t = MyClass() t.start()
Python的threading.Thread类有一个run方法，定义线程功能函数，可以覆盖该方法，创建自己的线程实例后，调用start启动，交给虚拟机进行调度，有执行机会就会调用run方法执行线程。
2、线程执行顺序
import threading from time import sleep class MyClass(threading.Thread): def run(self): for i in range(3): sleep(1) msg = self.name + "--->" + str(i) print(msg+'\n') def test(): for i in range(5): t = MyClass() t.start() if __name__ == '__main__': test()
多线程执行顺序是不确定的，sleep时，线程将被阻塞(Blocked)，到sleep结束后，线程进入就绪(Runnable)状态，等待调度。线程调度选择一个线程执行。以上代码能保证运行每个线程都运行完整的run函数，但是线程启动顺序、run函数每次循环执行的顺序不能确定。
总结：
每个线程默认有一个名字
当线程run方法结束时，该线程完成。
无法控制线程调度顺序，可以通过其它办法影响线程调度方式。
五、多线程共享全局变量(重点)
from threading import Thread from time import sleep gl_num = 10 def sing(): global gl_num for i in range(3): gl_num += 1 print("sing------>%d"%gl_num) def dance(): global gl_num print("sing------>%d" % gl_num) t1 = Thread(target=sing) t1.start() sleep(1) t2 = Thread(target=dance) t2.start()
列表当做参数传递：
from threading import Thread from time import sleep gl_num = [10, 20, 30] def sing(num): num.append(33) print("sing------>", num) def dance(num): sleep(1) print("sing------>", num) t1 = Thread(target=sing, args=(gl_num,)) t1.start() t2 = Thread(target=dance, args=(gl_num,)) t2.start()
同进程内的所有线程共享全局变量，方便多个线程共享数据
缺点，线程一单被修改造成多线程之间全局变量混乱现象(使用时保证全局变量不能被修改，线程非安全的)
六、线程同步和锁(重点)
1、线程同步
概念：协同步调，按预定的先后顺序执行，多线程修改全局变量，可能会出现意外结果，为了保证数据的正确性，需要对多个线程进行同步。
方法：使用Thread对象的Lock和Rlock实现简单线程同步，acquire和release方法对只允许一个线程操作的数据，可以将其放到acquire和release之间。
2、互斥锁
某个线程需要修改共享数据时，先将其锁定，此时资源状态为锁定，其它线程不允许修改；直到该线程释放资源，将资源状态调整非锁定，其它线程才能再次锁定该共享数据。互斥锁保证每次只有一个线程进行数据修改，能够保证多线程数据正确性。
threading模块中定义Lock类，方便的处理锁：
import threading # 创建锁 mutex = threading.Lock() # 锁定 mutex.acquire() # 解锁 mutex.release()
调用acquire之前没有锁，不会堵塞；已锁，会堵塞，直到这个锁解锁
案例：互斥锁两个线程对统一变量累加10万次
import threading from time import sleep gl = 0 mutex = threading.Lock() def sing(num): global gl for i in range(num): mutex.acquire() gl += 1 mutex.release() print("唱歌-----> %d" % gl) def dance(num): global gl for i in range(num): mutex.acquire() gl += 1 mutex.release() print("跳舞------>%d" % gl) t1 = threading.Thread(target=sing, args=(100000,)) t1.start() t2 = threading.Thread(target=dance, args=(100000,)) t2.start() while len(threading.enumerate()) != 1: sleep(1) print("最终结果： %d" % gl
锁的拆解过程：
当一个线程调用acquire()方法时锁定，状态是locked
-只允许有一个线程获得锁，另一个线程想使用，该线程变成blocked状态，阻塞，直至有锁的线程调用release()方法释放锁，此时变成unlocked状态。
-线程调度从阻塞线程中选择一个来调用锁，并使此线程进入运行running状态。
总结：
锁好处：确保了代码可以由某一线程从开始到结束独立运行
锁坏处：阻止了多线程并发执行，单线程执行效率低下；使用多个锁可能会造成死锁
3、死锁
解释：线程间共享多个资源时，两个线程并各站一部分资源，同时等待对方释放资源，会造成死锁。
如何避免死锁：
程序设计时尽量避免
添加超时时间等
