python多任务——线程、进程和协程

nee~

已于 2025-02-23 14:38:36 修改

阅读量201

点赞数

分类专栏： python 文章标签： python 开发语言

于 2021-01-06 20:25:58 首次发布

本文链接：https://blog.youkuaiyun.com/guo_qingxia/article/details/111479150

版权

python 专栏收录该内容

21 篇文章

订阅专栏

多任务——线程

多任务：操作系统可以同时运⾏多个任务

单核CPU执行多任务：操作系统轮流让各个任务交替执⾏，任务1执⾏0.01秒，切换到任务2，任务2执⾏0.01秒，再切换到任务3，执⾏0.01秒……这样反复执⾏下去。表⾯上看，每个任务都是交替执⾏的，但是，由于CPU的执⾏速度实在是太快了，我们感觉就像所有任务都在同时执⾏⼀样。

多核CPU执行多任务：由于任务数量远远多于CPU的核⼼数量，所以，操作系统也会⾃动把很多任务轮流调度到每个核⼼上执⾏。

并发：指的是任务数多于cpu核数，通过操作系统的各种任务调度算法，实现⽤多个任务“⼀起”执⾏（实际上总有⼀些任务不在执⾏，因为切换任务的速度相当快，看上去⼀起执⾏⽽已）
并⾏：指的是任务数⼩于等于cpu核数，即任务真的是⼀起执⾏的。

线程

官方文档：threading --- 基于线程的并行 — Python 3.13.2 文档

python的thread模块是⽐较底层的模块，python的threading 模块是对thread做了⼀些包装的，可以更加⽅便的被使⽤。

单个进程中执行每个任务就是一个线程。线程是进程中执行运算的最小单位。

使⽤threading模块，threading模块中包含了关于线程操作的丰富功能，包括：常用线程函数，线程对象，锁对象，递归锁对象，事件对象，条件变量对象，信号量对象，定时器对象，栅栏对象。

threading是一个创建多线程的库(调用threading库的threading.Thread方法），语法为：threading.Thread(target=函数名,args=(函数参数1,....函数参数n),name=’线程名’）

单线程

import time
def saySorry():
    print("亲爱的，我错了，我能吃饭了吗？")
    time.sleep(1)
if __name__ == "__main__":
    for i in range(5):
        saySorry()

运行结果：

亲爱的，我错了，我能吃饭了吗？
亲爱的，我错了，我能吃饭了吗？
亲爱的，我错了，我能吃饭了吗？
亲爱的，我错了，我能吃饭了吗？
亲爱的，我错了，我能吃饭了吗？

多线程

1. 每个线程默认有⼀个名字，尽管下⾯的例⼦中没有指定线程对象的name，但是python会⾃动为线程指定⼀个名字；
2. 当线程的run()⽅法结束时该线程完成；
3. ⽆法控制线程调度程序，但可以通过别的⽅式来影响线程调度的⽅式。

import threading
import time
#先定义函数再用Thread方法创建线程
def saySorry():
    print("亲爱的，我错了，我能吃饭了吗？")
    time.sleep(1)
if __name__ == "__main__":
    for i in range(5):
        t = threading.Thread(target=saySorry)
        # 启动线程，即让线程开始执⾏
        t.start()

可以明显看出使⽤了多线程并发的操作，花费时间要短很多（1秒内输出5条）。当调⽤ start() 时，才会真正的创建线程，并且开始执⾏。

threading.enumerate()：以列表形式返回当前所有存活的 Thread 对象。可以看出当前允许的线程数。

import threading
from time import sleep,ctime
def sing():
    for i in range(3):
        print("正在唱歌...%d"%i)
        sleep(1)
def dance():
    for i in range(3):
        print("正在跳舞...%d"%i)
        sleep(1)
if __name__ == '__main__':
    print('---开始---:%s'%ctime())
    t1 = threading.Thread(target=sing)
    t2 = threading.Thread(target=dance)
    t1.start()
    t2.start()

    while True:
        length = len(threading.enumerate())
        print('当前运⾏的线程数为：%d' % length)
        if length <= 1:
            break
        sleep(0.5)

运行结果

线程执行代码的封装

通过使⽤threading模块能完成多任务的程序开发，为了让每个线程的封装性更完美，所以使⽤threading模块时，往往会定义⼀个新的⼦类class，只要继承 threading.Thread 就可以了，然后重写 run ⽅法。

threading.Thread类有⼀个run()⽅法，⽤于定义线程的功能函数，可以在⾃⼰的线程类中覆盖该⽅法。⽽创建⾃⼰的线程实例后，通过Thread类的start()⽅法，可以启动该线程，交给python虚拟机进⾏调度，当该线程获得执⾏的机会时，就会调⽤run()⽅法执⾏线程。

import threading
import time
class MyThread(threading.Thread):
    def run(self):
        for i in range(3):
            time.sleep(1)
            #name属性中保存的是当前线程的名字
            msg = "I'm "+self.name+' @ '+str(i)
            print(msg)
if __name__ == '__main__':
    t = MyThread()
    t.start()

结果：

I'm Thread-1 @ 0
I'm Thread-1 @ 1
I'm Thread-1 @ 2

线程的执行顺序

#coding=utf-8
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)
            print(msg)
def test():
    for i in range(5):
        t = MyThread()
        t.start()
if __name__ == '__main__':
    test()

运行结果

另：多线程程序的执⾏顺序是不确定的。当执⾏到sleep语句时，线程将被阻塞（Blocked），到sleep结束后，线程进⼊就绪（Runnable）状态，等待调度。⽽线程调度将⾃⾏选择⼀个线程执⾏。上⾯的代码中只能保证每个线程都运⾏完整个run函数，但是线程的启动顺序、run函数中每次循环的执⾏顺序都不能确定。

1. 每个线程默认有⼀个名字，尽管上⾯的例⼦中没有指定线程对象的

name ，但是 python 会⾃动为线程指定⼀个名字。

2. 当线程的 run() ⽅法结束时该线程完成。

3. ⽆法控制线程调度程序，但可以通过别的⽅式来影响线程调度的⽅式。

多线程—共享全局变量

在⼀个进程内的所有线程共享全局变量，很⽅便在多个线程间共享数据。缺点就是，线程是对全局变量随意修改可能造成多线程之间对全局变量的混乱（即线程⾮安全）。

from threading import Thread
import time
g_num = 100
def work1():
    global g_num
    for i in range(3):
        g_num += 1
    print("----in work1, g_num is %d---"%g_num)
def work2():
    print("----in work2, g_num is %d---"%g_num)

print("---线程创建之前g_num is %d---"%g_num)
t1 = Thread(target=work1)
t1.start()
#延时⼀会，保证t1线程中的事情做完
time.sleep(1)
t2 = Thread(target=work2)
t2.start()

结果是：

---线程创建之前g_num is 100---
----in work1, g_num is 103---
----in work2, g_num is 103---

列表当做实参传递到线程

from threading import Thread
import time
def work1(nums):
    nums.append(44)
    print("----in work1---",nums)
def work2(nums):
    #延时⼀会，保证t1线程中的事情做完
    time.sleep(1)
    print("----in work2---",nums)
g_nums = [11,22,33]
t1 = Thread(target=work1, args=(g_nums,))
t1.start()
t2 = Thread(target=work2, args=(g_nums,))
t2.start()

结果是：

----in work1--- [11, 22, 33, 44]
----in work2--- [11, 22, 33, 44]

同步（协同步调）

同步就是协同步调，按预定的先后次序进⾏运⾏。如:你说完，我再说。"同"字从字⾯上容易理解为⼀起动作其实不是，"同"字应是指协同、协助、互相配合。如进程、线程同步，可理解为进程或线程A和B⼀块配合，A执⾏到⼀定程度时要依靠B的某个结果，于是停下来，示意B运⾏;B执⾏，再将结果给A，A再继续操作。

不同步时，如果多个线程同时对同⼀个全局变量操作，会出现资源竞争问题，从⽽数据结果会不正确。

import threading
import time
g_num = 0
def work1(num):
    global g_num
    for i in range(num):
        g_num += 1
    print("----in work1, g_num is %d---"%g_num)
def work2(num):
    global g_num
    for i in range(num):
        g_num += 1
    print("----in work2, g_num is %d---"%g_num)
print("---线程创建之前g_num is %d---"%g_num)
t1 = threading.Thread(target=work1, args=(1000000,))
t1.start()
t2 = threading.Thread(target=work2, args=(1000000,))
t2.start()
while len(threading.enumerate()) != 1:
    time.sleep(1)
print("2个线程对同⼀个全局变量操作之后的最终结果是:%s" % g_num)

结果是：

---线程创建之前g_num is 0---
----in work2, g_num is 1184155-------in work1, g_num is 1269087---

2个线程对同⼀个全局变量操作之后的最终结果是:1269087

通过线程同步来进⾏解决思路，如下:
1. 系统调⽤t1，然后获取到g_num的值为0，此时上⼀把锁，即不允许其他线程操作g_num；
2. t1对g_num的值进⾏+1；
3. t1解锁，此时g_num的值为1，其他的线程就可以使⽤g_num了，⽽且是g_num的值不是0⽽是1；
4. 同理其他线程在对g_num进⾏修改时，都要先上锁，处理完后再解锁，在上锁的整个过程中不允许其他线程访问，就保证了数据的正确性。

互斥锁

当多个线程⼏乎同时修改某⼀个共享数据的时候，需要进⾏同步控制。线程同步能够保证多个线程安全访问竞争资源，最简单的同步机制是引⼊互斥锁。

互斥锁为资源引⼊⼀个状态：锁定/⾮锁定。某个线程要更改共享数据时，先将其锁定，此时资源的状态为“锁定”，其他线程不能更改；直到该线程释放资源，将资源的状态变成“⾮锁定”，其他的线程才能再次锁定该资源。互斥锁保证了每次只有⼀个线程进⾏写⼊操作，从⽽保证了多线程情况下数据的正确性。

threading模块中定义了Lock类，可以⽅便的处理锁定。

# 创建锁

mutex = threading.Lock()

互斥锁 ( 重点 ) # 锁定

mutex.acquire()

# 释放

mutex.release()

acquire(blocking=True, timeout=-1)：获取锁，并将锁的状态改为“锁定”，成功返回True，失败返回False。当一个线程获得锁时，会阻塞其他尝试获取锁的线程，直到这个锁被释放掉。timeout默认值为-1，即将无限阻塞等待直到获得锁，如果设为其他的值时（单位为秒的浮点数），将最多阻塞等待timeout指定的秒数。当blocking为False时，timeout参数被忽略，即没有获得锁也不进行阻塞。
release()：释放一个锁，并将其状态改为“非锁定”，需要注意的是任何线程都可以释放锁，不只是获得锁的线程（因为锁不属于特定的线程）。release()方法只能在锁处于“锁定”状态时调用，如果在“非锁定”状态时调用则会报RuntimeError错误。

上锁解锁的过程：当⼀个线程调⽤锁的acquire()⽅法获得锁时，锁就进⼊“locked”状态。
每次只有⼀个线程可以获得锁。如果此时另⼀个线程试图获得这个锁，该线程就会变为“blocked”状态，称为“阻塞”，直到拥有锁的线程调⽤锁的release()⽅法释放锁之后，锁进⼊“unlocked”状态。
线程调度程序从处于同步阻塞状态的线程中选择⼀个来获得锁，并使得该线程进⼊运⾏（running）状态。

#使⽤互斥锁完成2个线程对同⼀个全局变量各加100万次的操作
import threading
import time
g_num = 0
def work1(num):
    global g_num
    for i in range(num):
        mutex.acquire()  # 上锁
        g_num += 1
        mutex.release()  # 解锁
def work2(num):
    global g_num
    for i in range(num):
        mutex.acquire()  # 上锁
        g_num += 1
        mutex.release()  # 解锁
print("---线程创建之前g_num is %d---"%g_num)
mutex = threading.Lock()
t1 = threading.Thread(target=work1, args=(1000000,))
t1.start()
time.sleep(10)
t2 = threading.Thread(target=work2, args=(1000000,))
t2.start()
while len(threading.enumerate()) != 1:
    time.sleep(1)
print("2个线程对同⼀个全局变量操作之后的最终结果是:%s" % g_num)

结果是：

---线程创建之前g_num is 0---
2个线程对同⼀个全局变量操作之后的最终结果是:2000000

锁的好处：确保了某段关键代码只能由⼀个线程从头到尾完整地执⾏。
锁的坏处：阻⽌了多线程并发执⾏，包含锁的某段代码实际上只能以单线程模式执⾏，效率就⼤⼤地下降了；
由于可以存在多个锁，不同的线程持有不同的锁，并试图获取对⽅持有的锁时，可能会造成死锁。

死锁

在线程间共享多个资源的时候，如果两个线程分别占有⼀部分资源并且同时等待对⽅的资源，就会造成死锁。尽管死锁很少发⽣，但⼀旦发⽣就会造成应⽤的停⽌响应。

如下例子，进入死锁状态：

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()

避免死锁

程序设计时要尽量避免（银⾏家算法）
添加超时时间等

多任务——进程

进程

程序：例如xxx.py这是程序，是⼀个静态的。

进程：⼀个程序运⾏起来后，代码+⽤到的资源称之为进程，它是操作系统

分配资源的基本单元。

不仅可以通过线程完成多任务，进程也是可以的。

multiprocessing 模块就是跨平台版本的多进程模块，提供了⼀个 Process类来代表⼀个进程对象，这个对象可以理解为是⼀个独⽴的进程，可以执⾏另外的事情。进程间不同享全局变量。

Process([group [, target [, name [, args [, kwargs]]]]])

target：如果传递了函数的引⽤，可以任务这个⼦进程就执⾏这⾥的代码
args：给target指定的函数传递的参数，以元组的⽅式传递
kwargs：给target指定的函数传递命名参数
name：给进程设定⼀个名字，可以不设定
group：指定进程组，⼤多数情况下⽤不到

Process 创建的实例对象的常⽤⽅法：

start()：启动⼦进程实例（创建⼦进程）
is_alive()：判断进程⼦进程是否还在活着
join([timeout])：是否等待⼦进程执⾏结束，或等待多少秒
terminate()：不管任务是否完成，⽴即终⽌⼦进程

Process 创建的实例对象的常⽤属性：

name：当前进程的别名，默认为Process-N，N为从1开始递增的整数
pid：当前进程的pid（进程号）

from multiprocessing import Process
import time

def run_proc():
    """⼦进程要执⾏的代码"""
    while True:
        print("----2----")
        time.sleep(1)

if __name__=='__main__':
    #创建⼦进程时，只需要传⼊⼀个执⾏函数和函数的参数，创建⼀个Process实例，⽤start()⽅法启动
    p = Process(target=run_proc)
    p.start()
    while True:
        print("----1----")
        time.sleep(1)

进程PID

# -*- coding:utf-8 -*-
from multiprocessing import Process
import os
import time

def run_proc():
    """⼦进程要执⾏的代码"""
    print('⼦进程运⾏中，pid=%d...' % os.getpid()) # os.getpid获取当前进程的进程号
    print('⼦进程将要结束...')

if __name__ == '__main__':
    print('⽗进程pid: %d' % os.getpid()) # os.getpid获取当前进程的进程号
    p = Process(target=run_proc)
    p.start()

给⼦进程指定的函数传递参数

# -*- coding:utf-8 -*-
from multiprocessing import Process
import os
from time import sleep

def run_proc(name, age, **kwargs):
    for i in range(10):
        print('⼦进程运⾏中，name= %s,age=%d ,pid=%d...' % (name, age, os.getpid()))
        print(kwargs)
        sleep(0.2)

if __name__=='__main__':
    p = Process(target=run_proc, args=('test',18), kwargs={"m":20
    p.start()
    sleep(1) # 1秒中之后，⽴即结束⼦进程
    p.terminate()
    p.join()

运行结果