搞定｜通过实际案例搞懂多任务线程

目录:

1. 多任务简介
2. 主线程和子线程的执行关系
3. 查看线程数量
4. 验证子线程的执行和创建
5. 线程通信
6. 线程之间的资源竞争
7. 锁(互斥锁和死锁)
8. 队列(Queue)
9. 线程同步
10. 生产者和消费者

1. 多任务简介

有很多的场景中的事情是同时进行的，比如开车的时候 手和脚共同来驾驶汽车，再比如唱歌跳舞也是同时进行的。

详细介绍可以查看参考链接:https://blog.csdn.net/weixin_42452337/article/details/93395692

1.1 程序中模拟多任务

import time

def sing():
    for i in range(3):
        print("正在唱歌...%d"%i)
        time.sleep(1)

def dance():
    for i in range(3):
        print("正在跳舞...%d"%i)
        time.sleep(1)

if __name__ == '__main__':
    sing()
    dance()

2. 主线程和子线程的执行关系

• 主线程会等待子线程结束之后在结束
• join() 等待子线程结束之后，主线程继续执行
• setDaemon() 守护线程，不会等待子线程结束

import threading
import time

def demo():
    # 子线程
    print("hello girls")
    time.sleep(1)
    
if __name__ == "__main__":
    for i in range(5):
        t = threading.Thread(target=demo)
        t.start()

运行结果:五个子线程都打印hello girls。

修改一下代码:

def demo():
    for i in range(5):
        print('hello 子线程')
        time.sleep(1)

if __name__ == '__main__':
    t = threading.Thread(target=demo)
    t.start()
    print('hello world!')

运行结果:

"""
hello 子线程
hello world!
hello 子线程
hello 子线程
hello 子线程
hello 子线程
"""

那么问题来了:按照解释性语言的规则,print('hello world!')这句应该最后执行,但是运行结果不是这样的,所以主线程会在子线程结束之后结束。

但是看到程序运行的结果不是这样:我们需要调整。

2.1join()

方式一 t.join()等待子线程结束,再执行主线程
def demo():
    for i in range(5):
        print('hello 子线程')
        time.sleep(1)

if __name__ == '__main__':
    t = threading.Thread(target=demo)
    t.start()
    t.join()
    print('hello world!')

运行结果:

"""
hello 子线程
hello 子线程
hello 子线程
hello 子线程
hello 子线程
hello world!
"""

2.2.setDaemon() 守护线程，不会等待子线程结束

def demo():
    for i in range(5):
        print('hello 子线程')
        time.sleep(1)

if __name__ == '__main__':
    t = threading.Thread(target=demo)
    t.setDaemon(True)
    t.start()
    print('hello world!')

运行结果如下:

# hello 子线程
# hello world!

3. 查看线程数量

threading.enumerate()   查看当前线程的数量

import threading
import time

def demo1():
    for i in range(5):
        print('demo1--%s'%i)
        time.sleep(1)

def demo2():
    for i in range(10):
        print('demo2--%s'%i)
        time.sleep(1)

def main():
    t1 = threading.Thread(target=demo1)
    t2 = threading.Thread(target=demo2)
    t1.start()
    t2.start()
    while True:
        print(len(threading.enumerate()))
        if len(threading.enumerate()) <= 1:
            break
        time.sleep(1)

if __name__ == '__main__':
    main()

运行结果如下:

demo1--0
demo2--0
3
demo2--1
3
demo1--1
demo2--2
3
demo1--2
demo2--3
3
demo1--3
demo2--4
demo1--4
3
demo2--5
2
demo2--6
2
demo2--7
2
demo2--8
2
demo2--9
2
1

可以看出:程序最终只有一个线程那就是主线程。

4. 验证子线程的执行与创建

当调用Thread的时候，不会创建线程。

当调用Thread创建出来的实例对象的start方法的时候，才会创建线程以及开始运行这个线程。

4.1继承Thread类创建线程

import threading
import time

class A(threading.Thread):
    
    def __init__(self,name):
        super().__init__(name=name)
    
    def run(self):
        for i in range(5):
            print(i)

if __name__ == "__main__":
    t = A('test_name')    
    t.start()

运行结果:

0
1
2
3
4

5. 线程间的通信(多线程共享全局变量)

在一个函数中，对全局变量进行修改的时候，是否要加global要看是否对全局变量的指向进行了修改，如果修改了指向，那么必须使用global，仅仅是修改了指向的空间中的数据，此时不用必须使用global。

线程是共享全局变量。

5.1 多线程参数-args

threading.Thread(target=test, args=(num,))

此处不做代码展示,下面的代码会展示。

6. 线程间的资源竞争

一个线程写入,一个线程读取,没问题,如果两个线程都写入呢？

import threading

num = 0

def demo1(nums):
    global num
    for i in range(nums):
        num += 1
    print('demo1==%s'%num)


def demo2(nums):
    global num
    for i in range(nums):
        num += 1
    print('demo2==%s'%num) 


def main():
    t1 = threading.Thread(target=demo1,args=(1000000,))
    t2 = threading.Thread(target=demo2,args=(1000000,))
    t1.start()
    t2.start()


if __name__ == '__main__':
    main()

运行结果:

demo2==1351678

demo1==1463250

这里我们会发现, 我们给两个函数传递的参数是1000000,每个函数都是进行100w次的+1操作, 按照我们的常识来说, 最后的结果应该是200w才对, 但是结果却是135168,1463250(这里的结果并不是固定的)。 产生这种结果的原因是因为python的解释器会把一个简单的+1操作分成多步:

1.获取num的值 2.将num的值+1 3.将运算完成的值赋给num

又因为这是多线程的, 所以cpu在处理两个线程的时候, 是采用雨露均沾的方式, 可能在线程一刚刚将num值+1还没来得及将新值赋给num时, 就开始处理线程二了, 因此当线程二执行完全部的num+=1的操作后, 可能又会开始对线程一的未完成的操作, 而此时的操作停留在了完成运算未赋值的那一步, 因此在完成对num的赋值后, 就会覆盖掉之前线程二对num的+1操作。

**解决方式:**就是接下来要提及的线程互斥锁.

import threading
import time
# 创建锁
mutex = threading.Lock()

# 锁定

# 解锁
num = 0

def demo1(nums):
    global num
   

    for i in range(nums):
        mutex.acquire()
        num += 1
        mutex.release()

    print('demo1==%s'%num)


def demo2(nums):
    global num
    for i in range(nums):
        mutex.acquire()
        num += 1
        mutex.release()
    print('demo2==%s'%num) 


def main():
    t1 = threading.Thread(target=demo1,args=(1000000,))
    t2 = threading.Thread(target=demo2,args=(1000000,))
    t1.start()
    t2.start()


if __name__ == '__main__':
    main()

demo1==1838868

demo2==2000000

7. 互斥锁和死锁

7.1 互斥锁

当多个线程几乎同时修改某一个共享数据的时候，需要进行同步控制。

某个线程要更改共享数据时，先将其锁定，此时资源的状态为"锁定",其他线程不能改变，只到该线程释放资源，将资源的状态变成"非锁定"，其他的线程才能再次锁定该资源。互斥锁保证了每次只有一个线程进行写入操作，从而保证了多线程情况下数据的正确性。

创建锁
mutex = threading.Lock()

锁定
mutex.acquire()

解锁
mutex.release()

7.2 死锁

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

import threading
import time

class MyThread1(threading.Thread):
    def run(self):
        # 对mutexA上锁
        mutexA.acquire()

        # mutexA上锁后，延时1秒，等待另外那个线程 把mutexB上锁
        print(self.name+'----do1---up----')
        time.sleep(1)

        # 此时会堵塞，因为这个mutexB已经被另外的线程抢先上锁了
        mutexB.acquire()
        print(self.name+'----do1---down----')
        mutexB.release()

        # 对mutexA解锁
        mutexA.release()

class MyThread2(threading.Thread):
    def run(self):
        # 对mutexB上锁
        mutexB.acquire()

        # mutexB上锁后，延时1秒，等待另外那个线程 把mutexA上锁
        print(self.name+'----do2---up----')
        time.sleep(1)

        # 此时会堵塞，因为这个mutexA已经被另外的线程抢先上锁了
        mutexA.acquire()
        print(self.name+'----do2---down----')
        mutexA.release()

        # 对mutexB解锁
        mutexB.release()

mutexA = threading.Lock()
mutexB = threading.Lock()

if __name__ == '__main__':
    t1 = MyThread1()
    t2 = MyThread2()
    t1.start()
    t2.start()

7.3 避免死锁

• 程序设计时要尽量避免
• 添加超时时间等

8. Queue线程

在线程中，访问一些全局变量，加锁是一个经常的过程。如果你是想把一些数据存储到某个队列中，那么Python内置了一个线程安全的模块叫做queue模块。

Python中的queue模块中提供了同步的、线程安全的队列类，包括FIFO（先进先出）队列Queue，LIFO（后入先出）队列LifoQueue。这些队列都实现了锁原语（可以理解为原子操作，即要么不做，要么都做完），能够在多线程中直接使用。可以使用队列来实现线程间的同步。

初始化Queue(maxsize)：创建一个先进先出的队列。
empty()：判断队列是否为空。
full()：判断队列是否满了。
get()：从队列中取最后一个数据。
put()：将一个数据放到队列中。

9. 线程同步

线程同步：即当有一个线程在对内存进行操作时，其他线程都不可以对这个内存地址进行操作，直到该线程完成操作， 其他线程才能对该内存地址进行操作，而其他线程又处于等待状态，实现线程同步的方法有很多，临界区对象就是其中一种。

天猫精灵:小爱同学

小爱同学:在

天猫精灵:现在几点了？

小爱同学：你猜猜现在几点了

由于线程同步问题信息过大感兴趣的可以看看这篇文章:http://blog.csdn.net/ebowtang/article/details/29905309

10. 生产者和消费者

生产者和消费者模式是多线程开发中常见的一种模式。通过生产者和消费者模式，可以让代码达到高内聚低耦合的目标，线程管理更加方便，程序分工更加明确。

生产者的线程专门用来生产一些数据，然后存放到容器中(中间变量)。消费者在从这个中间的容器中取出数据进行消费。

10.1 Lock版的生产者和消费者

import threading
import random

lock = threading.Lock()
gmoney = 0
gTimes = 0

class Producer(threading.Thread):

    def run(self):
        global gmoney
        global gTimes
        while True:
            lock.acquire()
            money = random.randint(0,100)
            if gTimes >= 10:
                lock.release()
                break
            gmoney += money
            gTimes += 1
            print("%s号消费者生产了%d元钱,有%d元钱"%(threading.current_thread().name,money,gmoney))
            lock.release()
            

class Comsumer(threading.Thread):

    def run(self):
        global gmoney
        global gTimes
        while True:
            lock.acquire()
            money = random.randint(0,100)
            if gmoney >= money:
                gmoney -= money
                print("%s号消费者消费了%d元钱,还剩%d元钱"%(threading.current_thread().name,money,gmoney))
            else:
                if gTimes >= 10:
                    lock.release()
                    break
                print("%s号消费者需要消费了%d元钱,但是还剩%d元钱,余额不足"%(threading.current_thread().name,money,gmoney))
            lock.release()


def main():
    for i in range(5):
        t1 = Producer(name="%s号生产者"%i)
        t1.start()

    for j in range(5):
        t2 = Comsumer(name="%s号消费者"%j)
        t2.start()

if __name__ == '__main__':
    main()

运行结果:

0号生产者号消费者生产了18元钱,有18元钱
0号生产者号消费者生产了47元钱,有65元钱
0号生产者号消费者生产了52元钱,有117元钱
0号生产者号消费者生产了70元钱,有187元钱
0号生产者号消费者生产了28元钱,有215元钱
0号生产者号消费者生产了44元钱,有259元钱
0号生产者号消费者生产了2元钱,有261元钱
0号生产者号消费者生产了84元钱,有345元钱
0号生产者号消费者生产了43元钱,有388元钱
0号生产者号消费者生产了87元钱,有475元钱
0号消费者号消费者消费了70元钱,还剩405元钱
0号消费者号消费者消费了11元钱,还剩394元钱
0号消费者号消费者消费了78元钱,还剩316元钱
0号消费者号消费者消费了23元钱,还剩293元钱
0号消费者号消费者消费了46元钱,还剩247元钱
0号消费者号消费者消费了84元钱,还剩163元钱
0号消费者号消费者消费了16元钱,还剩147元钱
0号消费者号消费者消费了98元钱,还剩49元钱

10.2 Condition版的生产者和消费者

import threading
import random
gMoney = 0
# 定义一个变量 保存生产的次数 默认是0次
gTimes = 0
# 定义一把锁
# gLock = threading.Lock()
gCond = threading.Condition()
# 定义生产者
class Producer(threading.Thread):

    def run(self):
        global gMoney
        global gTimes

        while True:
            gCond.acquire() # 上锁
            if gTimes >= 10:
                gCond.release()
                break
            money = random.randint(0,100)
            gMoney += money
            gTimes += 1
            print("%s生产了%d元钱，剩余%d元钱" % (threading.current_thread().name, money, gMoney))
            gCond.notify_all()
            gCond.release() # 解锁
# 定义消费者
class Consumer(threading.Thread):

    def run(self):
        global gMoney
        while True:
            gCond.acquire()  # 上锁
            money = random.randint(0, 100)

            while gMoney < money:
                if gTimes >= 10:
                    gCond.release()
                    return  # 这里如果用break只能退出外层循环，所以我们直接return
                print("%s想消费%d元钱，但是余额只有%d元钱了，并且生产者已经不再生产了！"%(threading.current_thread().name,money,gMoney))
                gCond.wait()
            # 开始消费
            gMoney -= money
            print("%s消费了%d元钱，剩余%d元钱" % (threading.current_thread().name, money, gMoney))
            gCond.release()

def main():
    # 开启5个生产者线程
    for x in range(5):
        th = Producer(name="生产者%d号" % x)
        th.start()
    # 开启5个消费者线程
    for x in range(5):
        th = Consumer(name="消费者%d号" % x)
        th.start()

if __name__ == '__main__':
    main()

运行结果:

生产者0号生产了26元钱，剩余26元钱
生产者0号生产了99元钱，剩余125元钱
生产者0号生产了37元钱，剩余162元钱
生产者0号生产了77元钱，剩余239元钱
生产者0号生产了3元钱，剩余242元钱
生产者0号生产了91元钱，剩余333元钱
生产者0号生产了51元钱，剩余384元钱
生产者0号生产了66元钱，剩余450元钱
生产者0号生产了43元钱，剩余493元钱
生产者2号生产了79元钱，剩余572元钱
消费者0号消费了70元钱，剩余502元钱
消费者0号消费了25元钱，剩余477元钱
消费者0号消费了47元钱，剩余430元钱
消费者0号消费了74元钱，剩余356元钱
消费者1号消费了12元钱，剩余344元钱
消费者2号消费了33元钱，剩余311元钱
消费者0号消费了89元钱，剩余222元钱
消费者0号消费了90元钱，剩余132元钱
消费者0号消费了54元钱，剩余78元钱
消费者4号消费了57元钱，剩余21元钱