Python 多线程超详细到位总结

目录
  • 多线程threading
  • 线程池
  • 线程互斥
  • lock与Rlock的区别

在实际处理数据时,因系统内存有限,我们不可能一次把所有数据都导出进行操作,所以需要批量导出依次操作。为了加快运行,我们会采用多线程的方法进行数据处理,以下为我总结的多线程批量处理数据的模板:

import threading
# 从数据库提取数据的类
class Scheduler():
    def __init__(self):
        self._lock = threading.RLock()
        self.start = 0
        # 每次取10000条数据
        self.step = 10000

    def getdata(self):
        # 上锁,以免多线程同时对数据库进行访问,取出重复数据
        self._lock.acquire()
        # 进行取数据操作
        data = 'select * from table' \
               'where id between self.start and self.start + self.step'
        # 取完数据后,指针后移
        self.start += self.step
        self._lock.release()
        return data

# 处理数据的过程写在这里
def processdata():
    # 从该实例中提取数据
    data = scheduler.getdata()
    while data:
        # 进行处理数据的具体操作:
        # 去重、补缺、运算...只要还有数据,本线程就继续取新数据
        # 然后再获取数据,进行循环
        data = scheduler.getdata()

# 创建多线程,threads_num为创建的线程数
def threads_scheduler(threads_num):
    threads = []
    for i in range(threads_num):
        # 创建线程
        td = threading.Thread(target=processdata, name='th'+str(i+1))
        threads.append(td)
    for t in threads:
        # 启动线程
        t.start()
        for t in threads:
            # 子线程守护
            t.join()
            print('数据已全部处理成功')

if __name__=='__main__':
    # 实例化一个调度器,初始化参数
    scheduler = Scheduler()
    # 创建线程,开始处理数据
    threads_scheduler(4)

主要分为三大部分:

  • Scheduler类,负责初始化参数,getdata方法负责提取数据
  • processdata方法中写具体处理数据的流程
  • threads_scheduler方法负责创建线程

Python多线程的知识我分为4部分进行讲解,以下带大家来回顾重点:

多线程threading

本章先为大家介绍了线程的相关概念:

主线程:当一个程序启动时,就有一个进程被操作系统(OS)创建,与此同时一个线程也立刻运行,该线程通常叫做程序的主线程(Main Thread)。因为它是程序开始时就执行的,如果你需要再创建线程,那么创建的线程就是这个主线程的子线程。

子线程:使用threading、ThreadPoolExecutor创建的线性均为子线程。

主线程的重要性体现在两方面:1.是产生其他子线程的线程;2.通常它必须最后完成执行,比如执行各种关闭动作。

在飞车程序中,如果没有多线程,我们就不能一边听歌一边玩飞车,听歌与玩游戏不能并行;在使用多线程后,我们就可以在玩游戏的同时听背景音乐。在这个例子中启动飞车程序就是一个进程,玩游戏和听音乐是两个线程。

Python提供了threading模块来实现多线程:threading.Thread可以创建线程;setDaemon(True)为守护主线程,默认为False;join()为守护子线程。

from time import sleep
import threading

def music(music_name):
    for i in range(2):
        print('正在听{}'.format(music_name))
        sleep(1)
        print('music over')

def game(game_name):
    for i in range(2):
        print('正在玩{}'.format(game_name))
        sleep(3)
        print('game over')

threads = []
t1 = threading.Thread(target=music,args=('稻香',))
threads.append(t1)
t2 = threading.Thread(target=game,args=('飞车',))
threads.append(t2)

if __name__ == '__main__':
    for t in threads:
        # t.setDaemon(True)
        t.start()

    for t in threads:
        t.join()
    print('主线程运行结束')

线程池

因为新建线程系统需要分配资源、终止线程系统需要回收资源,所以如果可以重用线程,则可以减去新建/终止的开销以提升性能。同时,使用线程池的语法比自己新建线程执行线程更加简洁。

Python为我们提供了ThreadPoolExecutor来实现线程池,此线程池默认子线程守护。它的适应场景为突发性大量请求或需要大量线程完成任务,但实际任务处理时间较短。

from time import sleep
# fun为定义的待运行函数
with ThreadPoolExecutor(max_workers=5) as executor:
    ans = executor.map(fun, [遍历值])
    for res in ans:
        print(res)

with ThreadPoolExecutor(max_workers=5) as executor:
    list = [遍历值]
    ans = [executor.submit(fun, i) for i in list]
    for res in as_completed(ans):
        print(res.result())

其中max_workers为线程池中的线程个数,常用的遍历方法有map和submit+as_completed。根据业务场景的不同,若我们需要输出结果按遍历顺序返回,我们就用map方法,若想谁先完成就返回谁,我们就用submit+as_complete方法。

线程互斥

我们把一个时间段内只允许一个线程使用的资源称为临界资源,对临界资源的访问,必须互斥的进行。互斥,也称间接制约关系。线程互斥指当一个线程访问某临界资源时,另一个想要访问该临界资源的线程必须等待。当前访问临界资源的线程访问结束,释放该资源之后,另一个线程才能去访问临界资源。锁的功能就是实现线程互斥。

我把线程互斥比作厕所包间上大号的过程,因为包间里只有一个坑,所以只允许一个人进行大号。当第一个人要上厕所时,会将门上上锁,这时如果第二个人也想大号,那就必须等第一个人上完,将锁解开后才能进行,在这期间第二个人就只能在门外等着。这个过程与代码中使用锁的原理如出一辙,这里的坑就是临界资源。

Python 的 threading 模块引入了锁。threading 模块提供了 Lock 类,它有如下方法加锁和释放锁:

  • acquire():对 Lock加锁,其中timeout参数指定加锁多少秒
  • release():释放锁
class Account:
    def __init__(self, card_id, balance):
        # 封装账户ID、账户余额的两个变量
        self.card_id= card_id
        self.balance = balance

def withdraw(account, money):
    # 进行加锁
    lock.acquire()
    # 账户余额大于取钱数目
    if account.balance >= money:
        # 吐出钞票
        print(threading.current_thread().name + "取钱成功!吐出钞票:" + str(money),end=' ')
        # 修改余额
        account.balance -= money
        print("\t余额为: " + str(account.balance))
    else:
        print(threading.current_thread().name + "取钱失败!余额不足")
    # 进行解锁
    lock.release()
# 创建一个账户,银行卡id为8888,存款1000元
acct = Account("8888" , 1000)

# 模拟两个对同一个账户取钱
# 在主线程中创建一把锁
lock = threading.Lock()
threading.Thread(name='窗口A', target=withdraw , args=(acct , 800)).start()
threading.Thread(name='窗口B', target=withdraw , args=(acct , 800)).start()

lock与Rlock的区别

区别一:Lock被称为原始锁,一个线程只能请求一次;RLock被称为重入锁,可以被一个线程请求多次,即锁中可以嵌套锁。

import threading

def main():
    lock.acquire()
    print('第一道锁')
    lock.acquire()
    print('第二道锁')
    lock.release()
    lock.release()

if __name__ == '__main__':
    lock = threading.Lock()
    main()

我们会发现这个程序只会打印“第一道锁”,而且程序既没有终止,也没有继续运行。这是因为Lock锁在同一线程内第一次加锁之后还没有释放时,就进行了第二次acquire请求,导致无法执行release,所以锁永远无法释放,这就是死锁。如果我们使用RLock就能正常运行,不会发生死锁的状态。

区别二:当Lock处于锁定状态时,不属于特定线程,可在另一个线程中进行解锁释放;而RLock只有当前线程才能释放本线程上的锁,不可由其他线程进行释放,所以在使用RLock时,acquire与release必须成对出现,即解铃还须系铃人。

import threading

def main():
    lock.release()
    print("在子线程解锁后打印")
if __name__ == '__main__':
    lock = threading.Lock()
    lock.acquire()
    t = threading.Thread(target=main)
    t.start()

在主线程中定义Lock锁,然后上锁,再创建一个子线程t运行main函数释放锁,结果正常输出,说明主线程上的锁,可由子线程解锁。

如果把上面的锁改为RLock则报错。在实际中设计程序时,我们会将每个功能分别封装成一个函数,每个函数中都可能会有临界区域,所以就需要用到RLock。

import threading
import time

def fun_1():
    print('开始')
    time.sleep(1)
    lock.acquire()
    print("第一道锁")
    fun_2()
    lock.release()

def fun_2():
    lock.acquire()
    print("第二道锁")
    lock.release()

if __name__ == '__main__':
    lock = threading.RLock()
    t1 = threading.Thread(target=fun_1)
    t2 = threading.Thread(target=fun_1)
    t1.start()
    t2.start()

一句话总结就是Lock不能套娃,RLock可以套娃;Lock可以由其他线程中的锁进行操作,RLock只能由本线程进行操作。

以上就是多线程所有内容,喜欢的小伙伴支持,收藏。

到此这篇关于Python 多线程超详细到位总结的文章就介绍到这了,更多相关Python 多线程内容请搜索我们以前的文章或继续浏览下面的相关文章希望大家以后多多支持我们!

(0)

相关推荐

  • Python多线程编程之threading模块详解

    一.介绍 线程是什么?线程有啥用?线程和进程的区别是什么? 线程是操作系统能够进行运算调度的最小单位.被包含在进程中,是进程中的实际运作单位.一条线程指的是进程中一个单一顺序的控制流,一个进程中可以并发多个线程,每条线程并行执行不同的任务. 二.Python如何创建线程 2.1 方法一: 创建Thread对象 步骤: 1.目标函数 2.实例化Thread对象 3.调用start()方法 import threading # 目标函数1 def fun1(num): for i in range(

  • Python 多线程其他属性以及继承Thread类详解

    一.线程常用属性 1.threading.currentThread:返回当前线程变量 2.threading.enumerate:返回一个包含正在运行的线程的list,正在运行的线程指的是线程启动后,结束前的状态 3.threading.activeCount:返回正在运行的线程数量,效果跟len(threading.enumer)一样 4.thr.setName:给线程设置名字 5.thr.getName:得到线程的名字. 举例: mport _thread as thread import

  • Python多线程threading创建及使用方法解析

    一.线程创建方法 1. 普通创建 import threading def run(name): for i in range(3): print(name) if __name__ == '__main__': t1 = threading.Thread(target=run, args=("t1",)) t2 = threading.Thread(target=run, args=("t2",)) t1.start() t2.start() ----------

  • Python多线程thread及模块使用实例

    多线程类似于同时执行多个不同程序,多线程运行有如下优点: 使用线程可以把占据长时间的程序中的任务放到后台去处理. 用户界面可以更加吸引人,这样比如用户点击了一个按钮去触发某些事件的处理,可以弹出一个进度条来显示处理的进度 程序的运行速度可能加快 在一些等待的任务实现上如用户输入.文件读写和网络收发数据等,线程就比较有用了.在这种情况下我们可以释放一些珍贵的资源如内存占用等等. 线程在执行过程中与进程还是有区别的.每个独立的线程有一个程序运行的入口.顺序执行序列和程序的出口.但是线程不能够独立执行

  • Python 多线程,threading模块,创建子线程的两种方式示例

    本文实例讲述了Python 多线程,threading模块,创建子线程的两种方式.分享给大家供大家参考,具体如下: GIL(全局解释器锁)是C语言版本的Python解释器中专有的,GIL的存在让多线程的效率变低(哪个线程抢到锁,就执行哪个线程).在IO密集型程序中,多线程依然比单线程效率高(GIL通过IO阻塞自动切换多线程). 解决GIL(全局解释器锁)的问题的三种方法: 1.不要用C语言版本的Python解释器. 2.让子线程运行其他语言代码(例如:主线程运行Python代码,子线程运行C语言

  • Python 多线程之threading 模块的使用

    简介 Python 通过 _thread 和 threading 模块提供了对多线程的支持,threading 模块兼具了 _thread 模块的现有功能,又扩展了一些新的功能,具有十分丰富的线程操作功能 创建线程 使用 threading 模块创建线程通常有两种方式: 1)使用 threading 模块中 Thread 类的构造器创建线程,即直接对类 threading.Thread 进行实例化,并调用实例化对象的 start 方法创建线程: 2)继承 threading 模块中的 Threa

  • Python多线程模块Threading用法示例小结

    本文实例讲述了Python多线程模块Threading用法.分享给大家供大家参考,具体如下: 步入正题前,先准备下基本知识,线程与进程的概念. 相信作为一个测试人员,如果从理论概念上来说其两者的概念或者区别,估计只会一脸蒙蔽,这里就举个例子来说明下其中的相关概念. 平安夜刚过,你是吃到了苹果还是香蕉呢...其实当你用手去接下对方苹果的时候,你的手臂就可以比喻成进程,你的五个手指就可以比喻成线程,所以很明显,线程可以说是进程的细化,没有进程就不会有线程. 这里还是说下必要的概念:    进程 是操

  • python中threading和queue库实现多线程编程

    摘要 本文主要介绍了利用python的 threading和queue库实现多线程编程,并封装为一个类,方便读者嵌入自己的业务逻辑.最后以机器学习的一个超参数选择为例进行演示. 多线程实现逻辑封装 实例化该类后,在.object_func函数中加入自己的业务逻辑,再调用.run方法即可. # -*- coding: utf-8 -*- # @Time : 2021/2/4 14:36 # @Author : CyrusMay WJ # @FileName: run.py # @Software:

  • Python 多线程超详细到位总结

    目录 多线程threading 线程池 线程互斥 lock与Rlock的区别 在实际处理数据时,因系统内存有限,我们不可能一次把所有数据都导出进行操作,所以需要批量导出依次操作.为了加快运行,我们会采用多线程的方法进行数据处理,以下为我总结的多线程批量处理数据的模板: import threading # 从数据库提取数据的类 class Scheduler(): def __init__(self): self._lock = threading.RLock() self.start = 0

  • python多线程超详细详解

    python中的多线程是一个非常重要的知识点,今天为大家对多线程进行详细的说明,代码中的注释有多线程的知识点还有测试用的实例. import threading from threading import Lock,Thread import time,os ''' python多线程详解 什么是线程? 线程也叫轻量级进程,是操作系统能够进行运算调度的最小单位,它被包涵在进程之中,是进程中的实际运作单位. 线程自己不拥有系统资源,只拥有一点儿在运行中必不可少的资源,但它可与同属一个进程的其他线程

  • Python matplotlib超详细教程实现图形绘制

    目录 前言 1. matplotlib.patches概述 2. 绘制图形方法 3. 绘制图形步骤 4. 绘制图形属性 设置透明度 设置颜色 5. 小试牛刀 前言 我们前面对matplotlib模块底层结构学习,对其pyplot类(脚本层)类提供的绘制折线图.柱状图.饼图.直方图等统计图表的相关方法,列举往期文章如下. Python利用 matplotlib 绘制直方图 Python用 matplotlib 绘制柱状图 python 用matplotlib绘制折线图详情 Python利用matp

  • Python OpenCV超详细讲解读取图像视频和网络摄像头

    0.准备工作 右击新建的项目,选择Python File,新建一个Python文件,然后在开头import cv2导入cv2库. 1.读取图像调用imread()方法获取我们资源文件夹中的图片使用imshow()方法显示图片,窗口名称为OutputwaitKey(0)这句可以让窗口一直保持,如果去掉这句,窗口会一闪而过 我们来看下效果: 2.读取视频VideoCapture()方法的参数就是视频文件循环中通过read不断地去读视频的每一帧,再通过imshow显示出来最后if语句代表按q可以退出程

  • Python OpenCV超详细讲解基本功能

    目录 准备工作 转成灰度图像 高斯模糊 边缘检测 膨胀运算 腐蚀运算 准备工作 右击新建的项目,选择Python File,新建一个Python文件,然后在开头import cv2导入cv2库. 转成灰度图像 调用imread()方法获取我们资源文件夹中的图片lena.png cvtColor()方法可以让我们的图片转换成任意颜色,第一个参数是我们要转换的图片,第二个参数是要转成的颜色空间,cv2.COLOR_BGR2GRAY就是由BGR变为GRAY,我们日常生活中都是RGB三通道顺序,而在Op

  • Python OpenCV超详细讲解调整大小与图像操作的实现

    目录 准备工作 重新调整图像大小 图像裁剪 准备工作 右击新建的项目,选择Python File,新建一个Python文件,然后在开头import cv2导入cv2库. 我们还要知道在OpenCV中,坐标轴的方向是x轴向右,y轴向下,坐标原点在左上角,比如下面这张长为640像素,宽为480像素的图片.OK,下面开始本节的学习吧. 查看图像大小 调用imread()方法获取我们资源文件夹中的图片lambo.png 输出图像的shape属性 img=cv2.imread("Resources/lam

  • Python OpenCV超详细讲解透视变换的实现

    目录 准备工作 场景描述 透视变换 准备工作 右击新建的项目,选择Python File,新建一个Python文件,然后在开头import cv2导入cv2库,import numpy并且重命名为np. 我们还要知道在OpenCV中,坐标轴的方向是x轴向右,y轴向下,坐标原点在左上角,比如下面这张长为640像素,宽为480像素的图片.OK,下面开始本节的学习吧. 场景描述 给定任意一张图像,从中分割出你需要的区域,并且以指定的大小显示出来.而且分割出的图像在线性空间中还是与显示的窗口是平行的.就

  • Python pip超详细教程之pip的安装与使用

    目录 1. pip的安装与卸载 1.1 pip的安装 1.2 pip的卸载 2. pip的使用 2.1 帮助信息 2.2 查看pip版本 2.3 更新pip版本 2.4 安装库 2.5 查看库 2.6 升级库 2.7 卸载库 3. 提高pip下载速度 1. pip的安装与卸载 1.1 pip的安装 python中有许多有用的库,要使用这些第三方库,需要安装pip 打开cmd,输入以下命令安装pip: python -m ensurepip --default-pip 出现如下图所示,代表pip安

  • C++可扩展性与多线程超详细精讲

    目录 一.可扩展性和多线程 二.线程示例 一.可扩展性和多线程 基于 Boost.Asio 之类的库开发程序与通常的 C++ 风格不同.可能需要更长时间才能返回的函数不再按顺序调用. Boost.Asio 不调用阻塞函数,而是启动异步操作.操作完成后应该调用的函数现在在相应的处理程序中调用.这种方法的缺点是顺序执行函数的物理分离,这会使代码更难理解. 诸如 Boost.Asio 之类的库通常用于实现更高的效率.无需等待操作完成,程序可以在其间执行其他任务.因此,可以启动多个同时执行的异步操作——

  • Python OpenCV超详细讲解图像堆叠的实现

    目录 准备工作 水平堆叠 垂直堆叠 图像栈堆叠 准备工作 右击新建的项目,选择Python File,新建一个Python文件,然后在开头import cv2导入cv2库,import numpy并且重命名为np. import cv2 import numpy as np 我们还要知道在OpenCV中,坐标轴的方向是x轴向右,y轴向下,坐标原点在左上角,比如下面这张长为640像素,宽为480像素的图片.OK,下面开始本节的学习吧. 水平堆叠 调用np的hstack()水平堆栈方法,参数是我们要

随机推荐