多任务之线程

多任务

什么是多任务？简单的说就是操作系统可以同时执行多个任务，如你一边听音乐，一边在用word文档，一边qq聊天

这就是多任务

现在，电脑都是多核，可以执行多任务，我们都知道，cpu执行代码都是顺序执行，但是单核cpu也可以执行多任务，这是为什么？

答案很简单，就是多个任务在cpu上交替执行，比如：音乐执行0.00001s，切换word文档执行0.00001s,再切换qq执行0.00001s，

这样反复执行下去，表面上看多个任务是交替执行的，但是由于cpu执行很快，我们人类察觉不出来，看到的就是多个任务同时在执行

这种执行方法叫并发(假的多个任务同时执行)

那真正的多个任务同时执行可以实现吗？当然可以，多个cpu不就行了，虽然现在我们的电脑是多核，但是电脑上的任务远远多余cpu，

这时操作系统就会把多个任务在cpu上轮流调度执行

当cpu数量>=任务数时，这时候执行方法就做并行(真正的多个任务同时执行)

python怎么实现多任务

1、通过多线程实现多任务

2、通过多进程实现多任务

多线程

多线程之函数

import threading
import time
def sing():
    print('我正在唱歌')
    time.sleep(1)
def dance():
    print('我正在跳舞')
    time.sleep(2)
if __name__ == '__main__':
    #创建一个对象，target作用就是知道要执行那一段代码
    thread1=threading.Thread(target=sing)
    thread2=threading.Thread(target=dance)
    #启动线程(对象)
    thread1.start()
    thread2.start()
    while 1:
        #获取当前的线程数
        thread_length=len(threading.enumerate())
        #获取当前的线程
        threadd=threading.enumerate()
        print('当前运行的线程数：{}'.format(thread_length))
        print('当前的线程:{}'.format(threadd))
        if thread_length<=1:
            break
        time.sleep(0.5)

多线程之类

import threading
import time

class Sti(threading.Thread):
    #类要实现多线程，类里面必须有run函数来执行threading.Thread
    def run(self):
        print('111111')
        time.sleep(1)
class Tu(threading.Thread):
    def run(self):
        print('22222')
        time.sleep(2)
if __name__ == '__main__':
    #创建一个对象，类的实例化
    t1=Sti()
    t2=Tu()
    #启动线程(对象)
    t1.start()
    t2.start()
    while 1:
        #获取当前的线程数
        thread_length=len(threading.enumerate())
        #获取当前的线程
        threadd=threading.enumerate()
        print('当前运行的线程数：{}'.format(thread_length))
        print('当前的线程:{}'.format(threadd))
        if thread_length<=1:
            break
        time.sleep(0.5)

互斥锁

上面我们我们学了多线程，你们有没有考虑一个问题，如果多个线程都抢一个资源时，会有什么后果？

就相当于多个人都用一个厕所，这就会出现一个问题，到底谁先上？

如，两个线程都强变量a，我们想要的结果，是sti输出10000000，tu输出20000000，但实际却不是

为什么会产生这个原因？

大家都知道单个cpu处理是，有个并发执行，就会出现一会执行sti这个线程，一会执行tu这个线程

怎样解决这个问题，就用互斥锁，就像多个人上一个厕所，一个上了，把门锁上了，其他人就得等到

他上完才能上，这就解决了抢资源的问题

 

import threading
import time
mutex1=threading.Lock()
a=0
class Sti(threading.Thread):
    def run(self):
        global a
        for i in range(10000000):
            a+=1
        print(a)
class Tu(threading.Thread):
    def run(self):
        global a
        for i in range(10000000):
            a+=1
        print(a)
if __name__ == '__main__':
    t1=Sti()
    t2=Tu()
    t1.start()
    t2.start()
    time.sleep(1)

 通过互斥锁解决多线程抢资源的问题

import threading
import time
#创建互斥锁
mutex1=threading.Lock()
#定义一个类，来继承threading.Thread这个类的属性
a=0
class Sti(threading.Thread):
    #类要实现多线程，类里面必须有run函数来执行threading.Thread
    def run(self):
        #上锁
        mutex1.acquire()
        global a
        for i in range(10000000):
            a+=1
        print(a)
        #开锁
        mutex1.release()
class Tu(threading.Thread):
    def run(self):
        # 上锁
        mutex1.acquire()
        global a
        for i in range(10000000):
            a+=1
        print(a)
        # 开锁
        mutex1.release()
if __name__ == '__main__':
    #创建一个对象，类的实例化
    t1=Sti()
    t2=Tu()
    #启动线程(对象)
    t1.start()
    t2.start()
    time.sleep(1)

死锁

对于互斥锁，有没有想到一个问题，就是有两个线程，a线程上用到了b线程的的资源，b线程也用到了a线程的资源，

a线程用了c互斥锁，也用到了d互斥锁，b线程用了c互斥锁，也用到了d互斥锁，这就会出现死锁

如：

import threading
import time
#创建互斥锁
mutex1=threading.Lock()
mutex2=threading.Lock()
#定义一个类，来继承threading.Thread这个类的属性
class Sti(threading.Thread):
    #类要实现多线程，类里面必须有run函数来执行threading.Thread
    def run(self):
        mutex1.acquire()
        print('121212')
        time.sleep(1)
        mutex2.acquire()
        print('11111')
        mutex2.release()
        mutex1.release()
class Tu(threading.Thread):
    def run(self):
        mutex2.acquire()
        print('1111')
        time.sleep(2)
        mutex1.acquire()
        print('2222')
        mutex1.release()
        mutex2.release()
if __name__ == '__main__':
    #创建一个对象，类的实例化
    t1=Sti()
    t2=Tu()
    #启动线程(对象)
    t1.start()
    t2.start()