「Python入门」Python多线程

2024-07-08 75 发布于福建

版权

本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《阿里云开发者社区用户服务协议》和《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。

本文涉及的产品

实时计算 Flink 版，5000CU*H 3个月

智能开放搜索 OpenSearch行业算法版，1GB 20LCU 1个月

实时数仓Hologres，5000CU*H 100GB 3个月

简介： 1. **线程与进程区别**：线程共享内存，进程独立；线程启动快，多线程效率高于多进程。2. **多线程使用**：直接使用Thread类，通过`target`指定函数，`args`传递参数；或继承Thread，重写`run`方法。3. **守护线程**：设置`setDaemon(True)`，主线程结束时，守护线程一同结束。4. **join线程同步**：主线程等待子线程完成，如`t.join()`。5. **线程锁**（Mutex）：防止数据竞争，确保同一时间只有一个线程访问共享资源。6. **RLock（递归锁）**：允许多次锁定，用于需要多次加锁的递归操作。

@TOC

前言

线程也叫轻量级进程，是操作系统能够进行运算调度的最小单位，它被包涵在进程之中，是进程中的实际运作单位。线程自己不拥有系统资源，只拥有一点儿在运行中必不可少的资源，但它可与同属一个进程的其他线程共享进程所拥有的全部资源。一个线程可以创建和撤销另一个线程，同一个进程中的多个线程之间可以并发执行。
多线程 线程在程序中是独立的、并发的执行流。与分隔的进程相比，进程中线程之间的隔离程度要小，它们共享内存、文件句柄和其他进程应有的状态。

进程之间不能共享内存，但线程之间共享内存非常容易。
操作系统在创建进程时，需要为该进程重新分配系统资源，但创建线程的代价则小得多。因此使用多线程来实现多任务并发执行比使用多进程的效率高。
python语言内置了多线程功能支持，而不是单纯地作为底层操作系统的调度方式，从而简化了python的多线程编程。

在这里插入图片描述

一、线程与进程的区别

线程共享内存，进程独立内存
线程启动速度块，进程启动速度慢，运行时速度没有可比性
同一个进程的线程间可以直接交流，两个进程想通信，必须通过一个中间代理来实现
创建新线程很简单，创建新进程需要对其父进程进行一次克隆
一个线程可以控制和操作同一线程里的其他线程，但是进程只能操作子进程

二、多线程的使用方式

2.1 直接使用

# 文件名 python1.py
# -*- coding:utf-8 -*-
# 线程直接使用
import threading
import time


# 需要多线程运行的函数
def fun(args):
    print("我是线程%s" % args)
    time.sleep(2)
    print("线程%s运行结束" % args)


# 创建线程
t1 = threading.Thread(target=fun, args=(1,))
t2 = threading.Thread(target=fun, args=(2,))
start_time = time.time()
t1.start()
t2.start()
end_time = time.time()
print("两个线程一共的运行时间为：", end_time-start_time)
print("主线程结束")

"""
执行 python python1.py
运行结果：
我是线程1
我是线程2两个线程一共的运行时间为： 0.0019996166229248047
主线程结束

线程1运行结束
线程2运行结束
"""

        
          
        
        
        
          
          AI 代码解读

在这里插入图片描述

2.2 继承式调用

# 文件名 python2.py
# 继承式调用
import threading
import time


class MyThreading(threading.Thread):
    def __init__(self, name):
        super(MyThreading, self).__init__()
        self.name = name

    # 线程要运行的代码
    def run(self):
        print("我是线程%s" % self.name)
        time.sleep(2)
        print("线程%s运行结束" % self.name)


t1 = MyThreading(1)
t2 = MyThreading(2)
start_time = time.time()
t1.start()
t2.start()
end_time = time.time()
print("两个线程一共的运行时间为：", end_time-start_time)
print("主线程结束")

"""
执行 python python2.py
运行结果：
我是线程1
我是线程2
两个线程一共的运行时间为： 0.0010724067687988281
主线程结束
线程2运行结束
线程1运行结束
"""

        
          
        
        
        
          
          AI 代码解读

在这里插入图片描述

三、守护线程

在Python多线程编程中，join方法的作用式线程同步。
守护线程，是为守护别人而存在的，当设置为守护线程后，被守护的主线程不存在后，守护线程也自然不存在。

Python多线程默认情况（设置线程setDaemon(False))，主线程执行完自己的任务后，就退出了，此时子线程会继续执行自己的任务，直到子线程任务结束
代码演示：threading中的两个创建多线成的例子都是。

# 守护线程
import threading
import time


class MyThreading(threading.Thread):
    def __init__(self, name):
        super(MyThreading, self).__init__()
        self.name = name

    # 线程要运行的代码
    def run(self):
        print("我是线程%s" % self.name)
        time.sleep(2)
        print("线程%s运行结束" % self.name)


t1 = MyThreading(1)
t2 = MyThreading(2)
start_time = time.time()
t1.setDaemon(True)
t1.start()
t2.setDaemon(True)
t2.start()
end_time = time.time()
print("两个线程一共的运行时间为：", end_time-start_time)
print("主线程结束")
"""
执行 python python3.py
后续执行结果以截图的形式呈现，文件名可自定义为xx.py，执行 python xx.py 指令即可.
"""

        
          
        
        
        
          
          AI 代码解读

在这里插入图片描述

四、 join线程同步

当不给程序设置守护进程时，主程序将一直等待子程序全部运行完成才结束

# join:线程同步
import threading
import time


class MyThreading(threading.Thread):
    def __init__(self, name):
        super(MyThreading, self).__init__()
        self.name = name

    # 线程要运行的代码
    def run(self):
        print("我是线程%s" % self.name)
        time.sleep(3)
        print("线程%s运行结束" % self.name)


threading_list = []
start_time = time.time()
for x in range(50):
    t = MyThreading(x)
    t.start()
    threading_list.append(t)

for x in threading_list:
    x.join()    # 为线程开启同步

end_time = time.time()
print("50个线程一共的运行时间为：", end_time-start_time)
print("主线程结束")

        
          
        
        
        
          
          AI 代码解读

在这里插入图片描述

五、线程锁(互斥锁Mutex)

一个进程下可以启用多个线程，多个线程共享父进程的内存空间，也就意味着每个线程可以访问同一份数据。

# 线程锁(互斥锁Mutex)
# -*- coding:utf8  -*-
import threading
import time

num = 100
threading_list = []


def fun():
    global num
    print("get num:", num)
    num += 1
    time.sleep(1)


for x in range(200):
    t = threading.Thread(target=fun)
    t.start()
    threading_list.append(t)

for x in threading_list:
    x.join()

print("nun:", num)

        
          
        
        
        
          
          AI 代码解读

在这里插入图片描述

六、 RLock（递归锁）

# RLock（递归锁）
import threading, time
def run1():
    lock.acquire()
    print("grab the first part data")
    global num
    num += 1
    lock.release()
    return num


def run2():
    lock.acquire()
    print("grab the second part data")
    global num2
    num2 += 1
    lock.release()
    return num2


def run3():
    lock.acquire()
    res = run1()
    print('--------between run1 and run2-----')
    res2 = run2()
    lock.release()
    print(res, res2)


if __name__ == '__main__':
    num, num2 = 0, 0
    lock = threading.RLock()
    for i in range(3):
        t = threading.Thread(target=run3)
        t.start()

while threading.active_count() != 1:
    print(threading.active_count())
else:
    print('----all threads done---')
    print(num, num2)

        
          
        
        
        
          
          AI 代码解读

注：在开发的过程中要注意有些操作默认都是线程安全的（内部集成了锁的机制），我们在使用的时无需再通过锁再处理

# RLock（递归锁）
import threading

data_list = []

lock_object = threading.RLock()


def task():
    print("开始")
    for i in range(1000000):
        data_list.append(i)
    print(len(data_list))


for i in range(2):
    t = threading.Thread(target=task)
    t.start()

        
          
        
        
        
          
          AI 代码解读

在这里插入图片描述

七、线程池

线程不是开的越多越好，开的多了可能会导致系统的性能更低了。

# 线程池
import time
from concurrent.futures import ThreadPoolExecutor  # 并行期货，线程池执行者
"""
pool = ThreadPoolExecutor(100)
pool.submit(函数名,参数1，参数2，参数...)
"""


def task(video_url, num):
    print("开始执行任务", video_url, num)     # 开始执行任务 www.vitian-99.vip 3
    time.sleep(1)


# 创建线程池，最多维护10个线程
threadpool = ThreadPoolExecutor(10)
# 生成100网址，并放入列表
url_list = ["www.vitian-{}.vip".format(i) for i in range(100)]
for url in url_list:
    """
    在线程池中提交一个任务，线程池如果有空闲线程，则分配一个线程去执行，执行完毕后在将线程交还给线程池，
    如果没有空闲线程，则等待。注意在等待时，与主线程无关，主线程依然在继续执行。
    """
    threadpool.submit(task, url, 3)

print("等待线程池中的任务执行完毕中······")
threadpool.shutdown(True)   # 等待线程池中的任务执行完毕后，在继续执行
print("END")

        
          
        
        
        
          
          AI 代码解读

在这里插入图片描述

# 线程池的回调
import time
import random
from concurrent.futures import ThreadPoolExecutor


def task(video_url):
    print("开始执行任务", video_url)
    time.sleep(1)
    return random.randint(0, 10)    # 将结果封装成一个Futuer对象，返回给线程池


def done(response):     # response就是futuer对象，也就是task的返回值分装的一个Futuer对象
    print("任务执行完后，回调的函数", response.result())    # 即Futuer.result()：取出task的返回值


# 创建线程池
threadpool = ThreadPoolExecutor(10)
url_list = ["www.xxxx-{}.com".format(i) for i in range(5)]
for url in url_list:
    futuer = threadpool.submit(task, url)    # futuer是由task返回的一个Future对象，里面有记录task的返回值
    futuer.add_done_callback(done)           # 回调done函数，执行者依然是子线程

# 优点：可以做分工，例如：task专门下载，done专门将下载的数据写入本地文件。

        
          
        
        
        
          
          AI 代码解读

在这里插入图片描述

「Python入门」Python多线程

前言

一、线程与进程的区别

二、多线程的使用方式

2.1 直接使用

2.2 继承式调用

三、守护线程

四、 join线程同步

五、线程锁(互斥锁Mutex)

六、 RLock（递归锁）

七、线程池

大数据与机器学习

热门文章

最新文章

相关课程

相关电子书

相关实验场景

推荐镜像

探索云世界

热门

云计算

大数据

云原生

人工智能

数据库

开发与运维

「Python入门」Python多线程

前言

一、线程与进程的区别

二、多线程的使用方式

2.1 直接使用

2.2 继承式调用

三、 守护线程

四、 join线程同步

五、 线程锁(互斥锁Mutex)

六、 RLock（递归锁）

七、 线程池

大数据与机器学习

热门文章

最新文章

相关课程

相关电子书

相关实验场景

推荐镜像

三、守护线程

五、线程锁(互斥锁Mutex)

七、线程池