美文网首页
Python 多任务 - 01 线程

Python 多任务 - 01 线程

作者: flowerflower | 来源:发表于2019-03-13 20:28 被阅读0次

    目录
    一、多任务的概念
    二、threading的基本使用
    三、多线程共享全局变量
    四、同步概念、互斥锁解决资源竞争的问题
    五、死锁

    一、多任务的概念

    简单地说,就是操作系统可以同时执行多个任务
    在代码里面,就是一个程序有多个地方同时执行
    打个比方,你一边写代码,一边在听歌,一边用着这浏览器上网,这就是多任务

    python中的多线程

    • python的threading模块是对thread做了一些包装的,可以更加方便的被使用

    二、threading的基本使用

    代码实现

    import threading
    import time
    
    
    def sing():
    
        for i in range(3):
            print("张三唱歌停不下来")
            time.sleep(1)
    
    
    def dance():
        for i in range(3):
            print("张三跳舞停不下来")
            time.sleep(1)
    
    
    def main():
        pass
    
        t1 = threading.Thread(target=sing)
        t2 = threading.Thread(target=dance)
        t1.start()  # 启动线程,即让线程开始执行
        t2.start()
    
    
    if __name__ == '__main__':
    
        main()
    
    
    thread的基本使用.gif

    说明

    • 当调用start()时,才会真正的创建线程,并且开始执行
    • 主线程会等待所有的子线程结束后才结束

    三、多线程共享全局变量

    • 函数里面修改全局变量
    import threading
    import time
    g_num = 100
    
    def test1():
    
        global g_num
        g_num += 1
        print("----test1 g_num = %d-----" % g_num)
    
    
    def test2():
        print("----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)
    
    
    if __name__ == '__main__':
        main()
    
    

    打印结果为:


    函数里面修改全局变量.png
    • 多线程里面传递参数
    import threading
    import time
    
    g_nums = [11, 22]
    
    
    def test1(temp):
        temp.append(33)
        print("----test1 temp = %s-----" % str(temp))
    
    
    def test2(temp):
        print("----test2 temp = %s-----" % str(temp))
    
    
    def main():
        # target 指定将来这个线程去哪个函数执行代码
        # args 指定将来调研函数的时候 传递什么数据过去
        t1 = threading.Thread(target=test1, args=(g_nums,))
        t2 = threading.Thread(target=test2, args=(g_nums,))
    
        t1.start()
        time.sleep(1)
    
        t2.start()
        time.sleep(1)
    
    
    if __name__ == '__main__':
        main()
    
    
    多线程里面传递参数.png

    小结

    • 子线程和子线程之间共享全局变量

    四、同步概念、互斥锁解决资源竞争的问题

    import threading
    import time
    g_num = 0
    
    def test1(num):
    
        global g_num
        for i in range(num):
            g_num += 1
        print("----test1 g_num = %d-----" % g_num)
    
    
    def test2(num):
        global g_num
        for i in range(num):
            g_num += 1
        print("----test2 g_num = %d-----" % g_num)
    
    
    def main():
    
        while True:
    
            count = int(input("请输入一个值:"))
    
            t1 = threading.Thread(target=test1, args=(count,))
            t2 = threading.Thread(target=test2, args=(count,))
    
            t1.start()
            t2.start()
    
            # 等待上面的2个线程执行完毕
            time.sleep(2)
            print("----最终 g_num = %d-----" % g_num)
    
    
    if __name__ == '__main__':
        main()
    
    
    资源竞争的问题.png

    由打印结果得知:当输入的值越大,计算出来的结果误差就越大。

    执行过程.png

    分析执行过程
    先执行线程1,当执行完第1,2步之后,g_num的值为1 还没有将结果存储g_num中。操作系统就开始执行线程2里面的函数,当执行完第1,2步 之后,g_num的值为1 还没有将结果存储g_num中,又去执行线程1里面的第三步了,此时线程1的g_num = 1, 接着又去执行线程2里面的第三步,此时线程2的g_num 也为1。按理来说,线程1执行完毕之后,再执行线程2时,此时g_num最终值为2

    对于上面计算错误的问题,可以通过线程同步来进行解决,接着往下看

    解决资源竞争的问题思路,如下:

    • 系统调用t1,然后获取到g_num的值为0,此时上一把锁,即不允许其他线程操作g_num
    • t1对g_num的值进行+1
    • t1解锁,此时g_num的值为1,其他的线程就可以使用g_num了,而且是g_num的值不是0而是1
    • 同理其他线程在对g_num进行修改时,都要先上锁,处理完后再解锁,在上锁的整个过程中不允许其他线程访问,就保证了数据的正确性

    互斥锁解决资源竞争的问题

    import threading
    import time
    g_num = 0
    
    # 创建锁
    mutex = threading.Lock()
    
    
    def test1(num):
    
        global g_num
        # 上锁,如果之前没有被上锁,那么此时上锁成功  反之上锁之前已经被锁上了 则会堵塞,直到这个锁被解开为止
        mutex.acquire()
        for i in range(num):
    
            g_num += 1
        # 解锁
        mutex.release()
        print("----test1 g_num = %d-----" % g_num)
    
    
    def test2(num):
        global g_num
        mutex.acquire()
        for i in range(num):
            g_num += 1
        mutex.release()
        print("----test2 g_num = %d-----" % g_num)
    
    
    def main():
    
        while True:
    
            count = int(input("请输入一个值:"))
    
            t1 = threading.Thread(target=test1, args=(count,))
            t2 = threading.Thread(target=test2, args=(count,))
    
            t1.start()
            t2.start()
    
            # 等待上面的2个线程执行完毕
            time.sleep(2)
    
            print("----最终 g_num = %d-----" % g_num)
    
    
    if __name__ == '__main__':
        main()
    
    互斥锁解决资源竞争的问题.png

    五、死锁

    在线程间共享多个资源的时候,如果两个线程分别占有一部分资源并且同时等待对方的资源,就会造成死锁。

    import threading
    import time
    
    mutexA = threading.Lock()
    mutexB = threading.Lock()
    
    class Thread1(threading.Thread):
        def run(self):
            # 对mutexA上锁
            mutexA.acquire()
    
            # mutexA上锁后,延时1秒,等待另外那个线程 把mutexB上锁
            print("----Thread1--mutexA-------")
            time.sleep(1)
            # 此时会堵塞,因为这个mutexB已经被另外的线程抢先上锁了
            mutexB.acquire()
            print("----Thread1--mutexB-------")
            mutexB.release()
            #  对mutexA解锁
            mutexA.release()
    
    
    class Thread2(threading.Thread):
        def run(self):
    
            mutexB.acquire()
            print("----Thread2--mutexB-------")
            time.sleep(1)
            mutexA.acquire()
            print("----Thread2--mutexB-------")
            mutexA.release()
            mutexB.release()
    
    def main():
        t1 = Thread1()
        t2 = Thread2()
        t1.start()
        t2.start()
    
    if __name__ == '__main__':
        main()
    
    死锁状态.png

    相关文章

      网友评论

          本文标题:Python 多任务 - 01 线程

          本文链接:https://www.haomeiwen.com/subject/fjgduqtx.html