Python 多任务 - 01 线程

目录
一、多任务的概念
二、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