1.多任务
在计算机中，操作系统可以同时运行多个任务,这就是多任务。那么如何解决多个任务同时运行呢，那就需要用到多线程。多任务可以通过并发和并行来完成，那么什么是并发和并行呢？
1.并发：指的是任务数多于cpu核数，通过操作系统的各种任务调度算法，实现用多个任务“一起”执行（实际上总有一些任务不在执行，因为切换任务的速度相当快，看上去一起执行而已），在实际开发中，并发是最常用的。
2.并行：当任务数小于或者等于cpu核数时，每一个任务都有对应的cpu来处理执行，即任务真的是一起执行的。
2.多任务的实现-多线程
实现多任务需要用到多线程，那么什么是线程呢？下面是对它的理解：
1.一个程序运行起来至少有一个进程，一个进程至少有一个线程
2.处理器cpu分配给线程，即cpu真正运行的是线程中的代码
3.分配cpu给线程时，是通过时间片轮训方式进行的
4.进程是操作系统分配程序执行资源的单位，而线程是进程的一个实体，
是CPU调度和分配的单位。
实现多线程的方式有2种方式：
1.python的thread模块是比较底层的模块，python的threading模块是对thread做了一些包装的，可以更加方便的被使用，通过threading模块可以创建线程
# 引入threading线程模块
import threading，time
def download_music():
'''模拟下载歌曲，需要5秒钟下载完成'''
for i in range(5):
time.sleep(1)# 休眠1秒
print("---正在下载歌曲%d---"% i)
def main():
# 创建线程对象t1 ,target: 指向新开启的线程要执行的代码
t1 = threading.Thread(target=download_music)
t1.start()# 启动线程，即线程开始执行
if__name__ =='__main__':
main()
2.继承Thread类，创建一个新的class，将要执行的代码 写到run函数里面
import threading，time
# 自定义类，继承threading.Thread
class MyThread(threading.Thread):
def run(self):
for i in range(5):
time.sleep(1)
# name属性中保存的是当前线程的名字
msg ="I'm "+ self.name +' @ '+ str(i)
print(msg)
if__name__ =='__main__':
# 通过MyThread创建线程对象
t1 = MyThread()
# 开始执行线程
t1.start()
3.多线程的注意点
1. 线程何时开启，何时结束
1.子线程何时开启，何时运行
当调用thread.start()时 开启线程，再运行线程的代码
2.子线程何时结束
子线程把target指向的函数中的语句执行完毕后，或者线程中的run函数代码执行完毕后，立即结束当前子线程
3.查看当前线程数量
通过threading.enumerate()可枚举当前运行的所有线程
4.主线程何时结束
所有子线程执行完毕后，主线程才结束
2. 线程的执行顺序
多线程的创建与执行都是无序的。
3.总结
1.每个线程默认有一个名字，尽管上面的例子中没有指定线程对象的name，但是python会自动为线程指定一个名字。
2.当线程的run()方法结束时该线程完成。
3.无法控制线程调度程序，但可以通过别的方式来影响线程调度的方式。
4.共享全局变量
先来看一段代码：
from threading import Thread
import time
g_nums = [11,22,33]
def main():
def work1(nums):
nums.append(44)
print("----in work1---",nums)
def work2(nums):
#延时一会，保证t1线程中的事情做完
time.sleep(1)
print("----in work2---",nums)
if __name__ == '__main__':
t1 = Thread(target=work1, args=(g_nums,))
t1.start()
t2 = Thread(target=work2, args=(g_nums,))
t2.start()
运行结果:
----inwork1--- [11,22,33,44]
----inwork2--- [11,22,33,44]
总结：
在一个进程内的所有线程共享全局变量，很方便在多个线程间共享数据
缺点就是，多线程对全局变量随意遂改可能造成全局变量的混乱（即线程非安全）
5.多线程开发可能遇到的问题
假设两个线程t1和t2都要对全局变量g_num(默认是0)进行加1运算，t1和t2都各对g_num加10次，g_num的最终的结果应该为20。
但是由于是多线程同时操作，有可能出现下面情况：
在g_num=0时，t1取得g_num=0。此时系统把t1调度为”sleeping”状态，把t2转换为”running”状态，t2也获得g_num=0
然后t2对得到的值进行加1并赋给g_num，使得g_num=1
然后系统又把t2调度为”sleeping”，把t1转为”running”。线程t1又把它之前得到的0加1后赋值给g_num。
这样导致虽然t1和t2都对g_num加1，但结果仍然是g_num=1。
所以，如果多个线程同时对同一个全局变量操作，会出现资源竞争问题，从而数据结果会不正确，即会遇到线程安全问题
6.使用同步机制解决线程安全问题-互斥锁
同步就是协同步调，按预定的先后次序进行运行。如:你说完，我再说。
"同"字从字面上容易理解为一起动作，其实不是，"同"字应是指协同、协助、互相配合。
如进程、线程同步，可理解为进程或线程A和B一块配合，A执行到一定程度时要依靠B的某个结果，于是停下来，示意B运行;B执行，再将结果给A;A再继续操作。
在多线程编程里面，一些敏感数据不允许被多个线程同时访问，此时就使用同步访问技术，保证数据在任何时刻，最多有一个线程访问，以保证数据的正确性。
互斥锁：
当多个线程几乎同时修改某一个共享数据的时候，需要进行同步控制
线程同步能够保证多个线程安全访问竞争资源，最简单的同步机制是引入互斥锁。
互斥锁为资源引入一个状态：锁定/非锁定
某个线程要更改共享数据时，先将其锁定，此时资源的状态为“锁定”，其他线程不能更改；直到该线程释放资源，将资源的状态变成“非锁定”，其他的线程才能再次锁定该资源。互斥锁保证了每次只有一个线程进行写入操作，从而保证了多线程情况下数据的正确性。
threading模块中定义了Lock类，可以方便的处理锁定：
# 1.创建锁
mutex = threading.Lock()
#2. 锁定
mutex.acquire()
#3. 释放
mutex.release()
注意：
如果这个锁之前是没有上锁的，那么acquire不会堵塞
如果在调用acquire对这个锁上锁之前 它已经被 其他线程上了锁，那么此时acquire会堵塞，直到这个锁被解锁为止
示例：使用互斥锁完成2个线程对同一个全局变量各加100万次的操作
import threading，time
g_num =0
def test1(num):
global g_num
for i in range(num):
mutex.acquire()# 上锁
g_num +=1
mutex.release()# 解锁
print("---test1---g_num=%d"%g_num)
def test2(num):
global g_num
for i in range(num):
mutex.acquire()# 上锁
g_num +=1
mutex.release()# 解锁
print("---test2---g_num=%d"%g_num)
# 创建一个互斥锁，默认是未上锁的状态
mutex = threading.Lock()
# 创建2个线程，让他们各自对g_num加1000000次
p1 = threading.Thread(target=test1, args=(1000000,))
p1.start()
p2 = threading.Thread(target=test2, args=(1000000,))
p2.start()
# 等待计算完成
while len(threading.enumerate()) !=1:
time.sleep(1)
print("2个线程对同一个全局变量操作之后的最终结果是:%s"% g_num)
运行结果：
---test1---g_num=1909909
---test2---g_num=2000000
2个线程对同一个全局变量操作之后的最终结果是:2000000
可以看到最后的结果，加入互斥锁后，其结果与预期相符。
上锁解锁过程：
当一个线程调用锁的acquire()方法获得锁时，锁就进入“locked”状态。
每次只有一个线程可以获得锁。如果此时另一个线程试图获得这个锁，该线程就会变为“blocked”状态，称为“阻塞”，直到拥有锁的线程调用锁的release()方法释放锁之后，锁进入“unlocked”状态。
线程调度程序从处于同步阻塞状态的线程中选择一个来获得锁，并使得该线程进入运行（running）状态。
7.死锁
在线程间共享多个资源的时候，如果两个线程分别占有一部分资源并且同时等待对方的资源，就会造成死锁。
尽管死锁很少发生，但一旦发生就会造成应用的停止响应。下面看一个死锁的例子
import threading ，time
printer_mutex = threading.Lock()# 打印机锁
paper_mutext = threading.Lock()# 纸张锁
class ResumeThread(threading.Thread):
"""编写个人简历任务的线程"""
def run(self):
print("ResumeThread：编写个人简历任务")
# 使用打印机资源，先对打印机加锁
printer_mutex.acquire()
print("--ResumeThread：正在使用打印机资源--")
time.sleep(1)# 休眠1秒
# 使用纸张耗材，先对纸张耗材加锁
paper_mutext.acquire()
print("--正在使用纸张资源--")
time.sleep(1)
paper_mutext.release()# 释放纸张锁
# 释放打印机锁
printer_mutex.release()
class PaperListThread(threading.Thread):
"""盘点纸张耗材任务的线程"""
def run(self):
print("PaperListThread:盘点纸张耗材任务")
# 使用纸张耗材，先对纸张耗材加锁
paper_mutext.acquire()
print("--PaperListThread:正在盘点纸张耗材--")
time.sleep(1)# 休眠1秒
# 使用打印机资源，打印清单
printer_mutex.acquire()
print("--正在使用打印机资源--")
time.sleep(1)
printer_mutex.release()# 释放打印机锁
# 释放纸张耗材锁
paper_mutext.release()
if__name__ =='__main__':
t1 = ResumeThread()
t2 = PaperListThread()
t1.start()
t2.start()
从运行结果可以看出，两个线程都在等待对方释放资源，造成了死锁。
避免死锁的方式：
1.程序设计时要尽量避免
2.添加超时时间等
