---

一、多任务是什么？

多个函数同时执行一件事情就是多任务，没有多任务的时候任务执行都是按照顺序的，而多任务的时候任务执行可以是同时的;
并行：真的多任务；
并发：假的多任务；

二、多任务-线程

import time
import threading
def sing():"""唱歌5秒"""for i in range(5):print("------正在唱歌------")time.sleep(1)
def dance():"""跳舞5秒"""for i in range(5):print("------正在跳舞------")time.sleep(1)
def main():t1=threading.Thread(target=sing)t2=threading.Thread(target=dance)t1.start()t2.start()
if __name__ =="__main__":main()

import  threading
def text1():for i in range(5):print("-----test1----%d----"%i)
def text2():for i in range(5):print("-----test2----%d----"%i)#因为线程执行的过程中没有slip延时，所以先谁后谁看cpu心情
def main():t1=threading.Thread(target=text1)t2 =threading.Thread(target=text2)t1.start()t2.start()print(threading.enumerate())
if __name__ =="__main__":main()

import  threading
import timedef text1():for i in range(5):print("-----test1----%d----"%i)
def text2():for i in range(5):print("-----test2----%d----"%i)#因为线程执行的过程中没有slip延时，所以先谁后谁看cpu心情
def main():t1=threading.Thread(target=text1)t2 =threading.Thread(target=text2)t1.start()time.sleep(1)#休眠（延时）t2.start()time.sleep(1)  # 休眠（延时）print(threading.enumerate())
if __name__ =="__main__":main()

import threading
import time
def text1():for i in range(5):print("------text1------------%d----"%i)time.sleep(1)
#如果创建thread时执行的函数结束则意味着这个线程结束了
def text2():for i in range(10):print("-------text2-----------%d----"%i)time.sleep(1)
def main():t1=threading.Thread(target=text1)t2=threading.Thread(target=text2)t1.start()#只有在运行时才建立线程并且线程运行t2.start()while True:print(threading.enumerate)#threading.enumerate查看当前线程信息#enumerate返回值是一个元组thread_num =len(threading.enumerate())print("线程数量是%d" % thread_num)if thread_num<=1:#当只剩一个主线程的时候则退出,主线程结束则全线程结束故而主线程要等到最后，保证其他线程执行完成breaktime.sleep(1)
if __name__=="__main__":main()#主线程最后退出还有一层作用就是清理各线程留下的垃圾

四、通过继承Tread类完成创建线程

import threading
import time
class Mythread(threading.Thread):def run(self):for i in range(3):time.sleep(1)msg="I'm"+self.name+'@'+str(i)#name属性中保存的是当前线程的名字print(msg)
if __name__=="__main__":t=Mythread()#调用类做线程的方法适合于一个线程里面做的东西比较复杂而且分成了很多个函数来做#这里创建了一个实例对象意味着只能创建一个线程，一个线程同一时间只能执行一个函数t.start()#在类里面自动调用run方法并且只能调用run，如果下面还有其他方法可以在run方法内部用语句调用，不可以用“t.其他方法()”

五、资源竞争

多个线程之间是共享全局变量的，但是这里有个问题如果一个线程写一个线程读则不会出问题但是两个线程都去写就会出现问题（资源竞争）

#定义一个全局变量
import threading
import timeg_num=100
def test1():global g_numg_num+=1print("-------in test1 g_num=%d-----"%g_num)
def test2():print("-------in test2 g_num=%d-----"%g_num)
def main():t1=threading.Thread(target=test1)t2=threading.Thread(target=test2)t1.start()time.sleep(1)t2.start()time.sleep(1)print("------in main Thread g_num=%d-----"%g_num)
if __name__=="__main__":main()

#定义一个全局变量
import threading
import timedef test1(temp):temp.append(33)print("-------in test1 temp=%s-----"%str(temp))
def test2(temp):print("-------in test2 temp=%s-----"%str(temp))
g_num=[11,22]
def main():t1=threading.Thread(target=test1,args=(g_num,))#args里面一定是一个元组所以一定要写逗号t2=threading.Thread(target=test2,args=(g_num,))t1.start()time.sleep(1)t2.start()time.sleep(1)print("------in main Thread g_num=%s-----"%str(g_num))
if __name__=="__main__":main()

六、同步与互斥锁

同步概念、互斥锁解决资源竞争问题（要么不做要么做完）；同步就是协同步调，按预定的先后次序运行；怎么做？互斥锁：当多个线程几乎同时修改某一个共享数据的时候，需要进行同步控制，线程同步能够保证多个线程安全访问的竞争资源，最简单的同步机制是引入互斥锁；某个线程要更改共享数据时，先将其锁定，此时资源的状态为锁定，其他线程不能更改，直到该线程释放资源，将资源的状态变成”非锁定“，其他的线程才能再次锁定该资源，互斥锁保证了每次只有一个线程进行写入操作，从而保证了多线程情况下数据的正确性。
#互斥锁创建mutex=threading.Lock()
#锁定mutex.acquire()
#释放mutex.release()

#定义一个全局变量
import threading
import time
g_num=0
def test1(num):global g_num#上锁，如果之前没有被上锁那么此时上锁成功#如果上锁之前已经被上锁，那么此时会堵塞在这里直到这个锁被解开mutex.acquire()for i in range(num):g_num+=1#解锁mutex.release()print("-----in test1 g_num=%d----"%g_num)def test2(num):global g_nummutex.acquire()for i in range(num):g_num+=1mutex.release()print("-----in test2 g_num=%d----"%g_num)
#创建一个互斥锁，默认是没有上锁的
mutex=threading.Lock()def main():t1=threading.Thread(target=test1,args=(100,))#args里面一定是一个元组所以一定要写逗号t2=threading.Thread(target=test2,args=(100,))t1.start()t2.start()time.sleep(3)if __name__=="__main__":main()

#定义一个全局变量
import threading
import time
g_num=0
def test1(num):global g_numfor i in range(num):mutex.acquire()g_num+=1mutex.release()print("-----in test1 g_num=%d----"%g_num)def test2(num):global g_numfor i in range(num):mutex.acquire()g_num+=1mutex.release()print("-----in test2 g_num=%d----"%g_num)
#创建一个互斥锁，默认是没有上锁的
mutex=threading.Lock()def main():t1=threading.Thread(target=test1,args=(100,))#args里面一定是一个元组所以一定要写逗号t2=threading.Thread(target=test2,args=(100,))t1.start()t2.start()time.sleep(3)if __name__=="__main__":main()

七、对峙与避免死锁

当多个线程同时遇到死锁问题时可能产生对峙现象，为了避免死锁有两种解决方法：1、程序设计时尽量避免（银行家算法）2、添加超时时间等；
银行家算法:

设Request(i)是进程Pi的请求向量，如果Request(i)[j]=k，表示进程Pi需要K个R(j)类型的资源。当Pi发现资源请求后系统将进行下列步骤

(1)如果Request(i)[j] <= Need[i,j],边转向步骤2),否则认为出错，因为它所请求的资源数已超过它所宣布的最大值。

(2)如果Request(i)[j] <= Available[i,j]，便转向步骤3)，否则，表示尚无足够资源，Pi需等待。

(3)系统试探着把资源分配给进程Pi，并需要修改下面数据结构中的数值；

Available[j] = Available[j] - Request(i)[j];

Allocation[i,j] = Allocation[i,j] + Request(i)[j];

Need[i,j] = Need[i,j] - Request(i)[j];