Python多线程阐述

最新推荐文章于 2024-09-17 23:15:58 发布
最新推荐文章于 2024-09-17 23:15:58 发布
阅读量127 收藏
点赞数
分类专栏： python|数据库 文章标签： python 多线程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/leitouguan8655/article/details/115027899
版权

目录

应用场景

  • 写了一个python脚本的接口，线上需要对这个接口做高并发调用，所以线下需要模拟高并发场景，测试接口性能。
  • 缩短运行时间
  • 有并发需求的时候需要用到，比如页面同时点击。

名次解释:线程

  • 线程是操作系统能够进行运算调度的最小单位。
  • 线程被包含在进程中，是进程中实际处理单位。
  • 一条线程就是一堆指令集合，一条线程是指进程中一个单一顺序的控制流。
  • 一个进程中可以并发多个线程，每条线程并行执行不同的任务。
  • 一个进程只能运行在一个核中，所以如果多线程运行，这些线程都是在一个核中运行。

多线程案例

python提供了多种模块用来支持多线程编程

  • thread（在python3中改名为_thread）
  • threading
    thread和threading模块都可以用来创建和管理线程，而thread模块提供了基本的线程和锁支持，threading提供的是更高级的完全的线程管理，一般应用程序推荐使用更高级的threading模块。
    案例1：
    执行同一个任务，单线程运行程序花费了6.02283787727356秒，运行顺序上第一个线程执行完了才执行第二个线程的。
#!/usr/bin/python
# -*- coding: utf-8 -*-
"""
@author:
@contact:
@time:
"""
import time
from datetime import datetime


def Test(name):
    for i in range(3):
        print(name, datetime.now())
        time.sleep(1)

def main():
    Test("one")
    Test("two")

if __name__ == '__main__':
    start = time.time()
    main()
    end = time.time()
    print("运行程序花费了%s秒" % (end - start))

'''
one 2021-03-19 16:01:11.253621
one 2021-03-19 16:01:12.260874
one 2021-03-19 16:01:13.263720
two 2021-03-19 16:01:14.267094
two 2021-03-19 16:01:15.269936
two 2021-03-19 16:01:16.273119
运行程序花费了6.02283787727356秒

Process finished with exit code 0

'''

多线程运行程序花费了3.024076461791992秒，运行顺序上两个线程一起运行的。

#!/usr/bin/python
# -*- coding: utf-8 -*-
"""
@author:
@contact:
@time:
"""
import threading
import time
from datetime import datetime


def Test(name):
    for i in range(3):
        print(name, datetime.now())
        time.sleep(1)

def main():
    t1 = threading.Thread(target=Test, args=("one",))  # 调用threading.Thread函数，target参数是要执行的函数，args是要传入的参数，为元组类型
    t2 = threading.Thread(target=Test, args=("two",))
    t1.start()  # 启动线程
    t2.start()
    t1.join()  # 必须等子线程运行完了父进程才可以运行
    t2.join()

if __name__ == '__main__':
    start = time.time()
    main()
    end = time.time()
    print("运行程序花费了%s秒" % (end - start))
'''
one 2021-03-19 16:03:23.071051
two 2021-03-19 16:03:23.071051
two 2021-03-19 16:03:24.085559
one 2021-03-19 16:03:24.085559
one 2021-03-19 16:03:25.090119
two 2021-03-19 16:03:25.090119
运行程序花费了3.024076461791992秒

Process finished with exit code 0

'''

案例2：
同样，多线程模式下，运行顺序上两个线程一起进行的。

#!/usr/bin/python
# -*- coding: utf-8 -*-
"""
@author:
@contact:
@time:
"""
import threading
import time


def mission1(num):
    for i in range(0, num):
        print("mission1......" + str(i))
        time.sleep(1)                                            # 此处要插入间隔，否则看不出多线程的区别

def mission2(num):
    for i in range(0, num):
        print("mission2......" + str(i))
        time.sleep(1)

if __name__ == '__main__':
    m1 = threading.Thread(target=mission1, args=(5, ))           # target为任务名，args为传递进任务的参数
    m2 = threading.Thread(target=mission2, args=(5, ))
    m1.start()                                                   # 开始任务
    m2.start()
'''
mission1......0
mission2......0
mission2......1
mission1......1
mission2......2
mission1......2
mission1......3
mission2......3
mission2......4
mission1......4

Process finished with exit code 0
'''

多线程冲突

考虑这样一种情况：

  • 一个列表里所有元素都是0，线程"set"从后向前把所有元素改成1，而线程"print"负责从前往后读取列表并打印。那么，可能线程"set"开始改的时候，线程"print"便来打印列表了，输出就成了一半0一半1，这就是数据的不同步。为了避免这种情况，引入了锁的概念。锁有两种状态——锁定和未锁定。每当一个线程比如"set"要访问共享数据时，必须先获得锁定；如果已经有别的线程比如"print"获得锁定了，那么就让线程"set"暂停，也就是同步阻塞；等到线程"print"访问完毕，释放锁以后，再让线程"set"继续。经过这样的处理，打印列表时要么全部输出0，要么全部输出1，不会再出现一半0一半1的尴尬场面。

或者这样的：

  • 假设你银行卡里有1000块，使用两台机器同时登入这张卡，此时两台机器所识别的这张卡的余额都是1000块，这时候操作机器的两个人同时按下取款1000块，机器就会吐出2000块。

多线程冲突的根本原因

  • 多线程的优势在于可以同时运行多个任务，但是当多线程调用同一个函数涉及到共享变量时，会发生多线程冲突。

解决办法

  • 线程锁就是保护公共资源，一次只能让一个线程访问。

案例1

#!/usr/bin/python
# -*- coding: utf-8 -*-
"""
@author:
@contact:
@time:
"""
import threading


money = 0

# # 定义一个函数用于存钱
# def addMoney():
#
#     global money
#     for i in range(1000000):
#         money += 1
#     print(money)

# 线程冲突情况
# def conflict():
#     # 有五个线程，这五个线程同时取用同一个资源
#     for _ in range(5):
#         t = threading.Thread(target=addMoney)
#         t.start()
#     pass
# conflict()

"""
1247040
1282304
2705568
2861408
2922634

Process finished with exit code 0
"""

# 给资源加锁
lock = threading.Lock()  # 互斥锁

def addMoney2():
    global money
    # 给公共资源处理过程加锁
    if lock.acquire():
        for i in range(1000000):
            money+=1
        print(money)
  
    lock.release()  #释放

def threadLock():
    for _ in range(5):
        t = threading.Thread(target=addMoney2)
        t.start()
threadLock()
'''
1000000
2000000
3000000
4000000
5000000

Process finished with exit code 0
'''

案例2
案例2说的是上面的银行卡案例，加锁前：

#!/usr/bin/python
# -*- coding: utf-8 -*-
"""
@author:
@contact:
@time:
"""
import threading
import time

account = 1000

def withdraw(num):
    global account
    if num <= account:
        time.sleep(1)                # 给予判断的余地
        t = account - num
        account = t
        print("已取出" + str(num))
    else:
        print("余额不足")

if __name__ == '__main__':
    m1 = threading.Thread(target=withdraw, args=(1000, ))
    m2 = threading.Thread(target=withdraw, args=(1000, ))
    m1.start()
    m2.start()
    
'''
已取出1000
已取出1000

Process finished with exit code 0
'''

加锁后：

#!/usr/bin/python
# -*- coding: utf-8 -*-
"""
@author:
@contact:
@time:
"""
import threading
import time

account = 1000

def withdraw(num):
    global account
    lock.acquire()                   # 加锁
    if num <= account:
        time.sleep(1)                # 给予判断的余地
        t = account - num
        account = t
        print("已取出" + str(num))
    else:
        print("余额不足")
    lock.release()                   # 解锁

if __name__ == '__main__':
    lock = threading.Lock()          # 生成锁

    m1 = threading.Thread(target=withdraw, args=(1000, ))
    m2 = threading.Thread(target=withdraw, args=(1000, ))

    m1.start()
    m2.start()
'''
已取出1000
余额不足

Process finished with exit code 0
'''

案例3：

  • 案例3没有涉及线程冲突，案例3是“多线程案例”中案例1的延伸，对案例1中的多线程上了一个锁，这样当我们的线程1和线程2都同时调用该函数时,必须等线程1执行完了线程2再执行，这样，程序花费的时间就相当于单线程时候的6秒了，也就是上了锁后，多线程变成了单线程，运行效率降低，上锁是解决线程冲突非常不明智的一种做法。
#!/usr/bin/python
# -*- coding: utf-8 -*-
"""
@author:
@contact:
@time:
"""
import threading
import time
from datetime import datetime
from threading import Lock

lock = Lock()  # 得到一个Lock对象


def Test(name):
    with lock:
        for i in range(3):
            print(name, datetime.now())
            time.sleep(1)


def main():
    t1 = threading.Thread(target=Test, args=("one",))  # 调用threading.Thread函数，target参数是要执行的函数，args是要传入的参数，为元组类型
    t2 = threading.Thread(target=Test, args=("two",))
    t1.start()  # 启动线程
    t2.start()
    t1.join()  # 必须等子线程运行完了父线程才可以运行
    t2.join()


if __name__ == '__main__':
    start = time.time()
    main()
    end = time.time()
    print("运行程序花费了%s秒" % (end - start))
'''
one 2021-03-20 15:18:22.841910
one 2021-03-20 15:18:23.862553
one 2021-03-20 15:18:24.874606
two 2021-03-20 15:18:25.881377
two 2021-03-20 15:18:26.883645
two 2021-03-20 15:18:27.887927
运行程序花费了6.061808824539185秒

Process finished with exit code 0
'''

参考资料

Python多线程_thread和Threading
python 使用threading模块解决多线程问题
python两种方法解决线程冲突问题

小时不识月123
关注
专栏目录
python多线程原理qthread_【Python】多线程个人使用理解之_thread
weixin_39922151的博客
12-17 540
Python 并发编程个人理解在工作中遇到了一些Python编程中的问题，借此学习了Python的并发编程。网上说的都很好，我就不重复说了。我说说自己在实际运用中的理解。我的需求是要在一个脚本里面实现一个对游戏按钮非常快的连续点击，但是使用的框架却是非常慢的，单线程远远达不到要求。这个时候我考虑到了使用Python的多线程。通过了解，我知道了Python有俩个多线程API，一个是比较简单的_thr...
深入浅出Python多线程、多进程和并发编程
u013112984的博客
08-15 1137
并发编程是解决现代计算机应用中性能瓶颈的重要工具，本文的目的是帮助你掌握这一强大技术，让你能够更好地应对多任务、高并发的编程需求。通过开发这两个通用函数模板，用户可以在自己的项目中轻松使用多线程和多进程，只需编写具体的任务函数并传入合适的线程数量或进程数量，即可快速实现并发处理，提高程序的性能和效率。这个并发通用函数模板允许用户同时使用多线程和多进程，根据实际情况选择合适的线程数量和进程数量，充分利用硬件资源，提高程序的性能。一个常见的方法是使用细粒度的锁，以减少锁的粒度，只保护必要的资源。
简单阐述python多线程
ajream的博客
09-09 136
python多线程 python中创建多线程方法有两种，这里只介绍简单的一种: from threading import Thread #导入模块 import time def test(thread_num): #线程需要执行的函数 print('线程%d:aaaaaaa' % thread_num) time.sleep(2) print('线程%d:bbbbbbb' % thread_num ) time.sleep(2)
python多线程详解_Python多线程详解
weixin_39997664的博客
12-05 91
前言由于最近的工作中一直需要用到Python去处理数据，而在面对大量的数据时，Python多线程的优势就展现出来了。因而借此机会，尽可能详尽地来阐述Python多线程。但对于其更底层的实现机制，在此不做深究，仅是对于之前的一知半解做个补充，也希望初学者能够通过这篇文章，即便是照葫芦画瓢，也能够用起来。Threading类ipythonthreading模块下包含的函数有很多，在此也不一一说明，具体...
python多线程并发请求_python并发之一：一篇文章搞懂python多线程（理论+实践）...
weixin_39819152的博客
02-20 1544
python多线程进程和线程是操作系统领域非常重要的概念，对于二者之间的联系与区别，本文不做过多阐述，这方面资料网上有非常多，如有需要请先自行查阅。1 基础知识之“鸡肋”的python多线程和GILPython是一种解释型语言，而对于python主流也是官方的解释器CPython来说，每一个进程都会持有一个全局解释锁GIL(Global Interpreter Lock)。一个进程运行python...
Python多线程编程
OneFine的技术博客
02-28 8826
1. 简介/动机 在多线程（multithreaded， MT）编程出现之前，计算机程序的执行是由单个步骤序列组成的，该序列在主机的 CPU 中按照同步顺序执行。无论是任务本身需要按照步骤顺序执行，还是整个程序实际上包含多个子任务，都需要按照这种顺序方式执行。那么，假如这些子任务相互独立，没有因果关系（也就是说，各个子任务的结果并不影响其他子任务的结果），这种做法是不是不符合逻辑呢？要是让这些独立...
python实现多线程输出123123
qq_42293758的博客
04-18 3566
昨天师兄线上面试某公司C++程序员实习生，作为师弟的我当然有幸见到了三道编程题。其中印象最深是其中一道多线程的问题，其要求是同时开启三个线程，分别只能输出1，2，3，并让三个线程按顺序输出打印123123123… 这道问题简单来说就是一种红绿灯，我们先让红灯亮，过一段时间后黄灯亮，再过一段时间后绿灯量，以此类推。一般对于多线程而言，可以很容易的实现这三种颜色的切换，但是再不对其进行控制的话，他的执...
Python多线程爬取小说网站小说
weixin_43495948的博客
03-16 755
问题阐述 爬取网站小说，这里我们以努努书坊中爬取刘慈欣的小说球状闪电为例子！ 技术支持 python多线程 request+beautifulSoup解析网页 代码演示【直接粘贴即可运行】 import os import threading from queue import Queue import requests from bs4 import BeautifulSoup CRAWL_EXIT = False class ThreadCrawl(threading.Thread): d
python多线程queue_Python多线程通信queue队列用法实例分析
weixin_39839410的博客
12-03 232
本文实例讲述了Python多线程通信queue队列用法。分享给大家供大家参考，具体如下：queue:什么是队列：是一种特殊的结构，类似于列表。不过就像排队一样，队列中的元素一旦取出，那么就会从队列中删除。线程之间的通信可以使用队列queue来进行线程如何使用queue.Queue【还有其他类型的对象下面讲】来通信：1.创建一个Queue对象：对象=queue.Queue(x)，x是队列容量，x可以...
几分钟搞定python多线程
12-21
在本文中，我们将深入理解Python的多线程，并通过实例来阐述其工作原理。 首先，多线程的基本思想是将一个大的任务分解成若干个小任务，每个任务在不同的线程中独立运行。在Python中，可以使用`threading`模块来...
linux 下python多线程递归复制文件夹及文件夹中的文件
09-18
3. Python多线程编程的注意事项： - 线程安全问题，需要考虑共享资源的同步访问。 - `GIL`(全局解释器锁)的限制，意味着Python的多线程并不能充分利用多核CPU。 - 可以使用`multiprocessing`模块来代替`threading...
Python多线程处理实例详解【单进程/多进程】
09-19
### Python多线程处理实例详解【单进程/多进程】 #### 概述 在Python编程中，多线程处理是一种非常实用的技术，尤其在需要同时处理多个任务或提高程序执行效率时更为突出。本文将详细介绍如何在Python中实现单进程...
python 线程的五个状态
12-16
线程的状态管理是理解并优化多线程程序的关键，下面将详细阐述Python线程的五个状态及其转换。 1. 新建状态：当使用`Thread`类或其子类创建线程对象时，线程处于新建状态。在这个阶段，线程尚未启动，即使已经定义...
[Python数据可视化]Plotly Express: 地图数据可视化的魅力
最新发布
William数据分析的博客
09-17 888
在数据分析和可视化的世界中，地图数据可视化是一个强大而直观的工具，它可以帮助我们更好地理解和解释地理数据。Python 的 Plotly Express 库提供了一个简单而强大的方式来创建各种地图。本文将通过一个简单的示例，展示如何使用 Plotly Express 来创建一个交互式的地图，并探讨其在地图数据可视化方面的应用。
Tcl lnit error: Can’t find a usable init.tcl in the following directories 问题解决
梦想闹钟
09-15 544
实际研究后发现，其实py2exe已经把打包需要的lib放在dist文件夹下了，但是打包后的程序运行后却没有去lib下找，而是去找系统自带的环境变量里找，所以找不到。这个问题出现在我用py2exe打包了一个包含tkinter的图形化界面，在当前电脑上运行无问题，在移动到新电脑上后提示报错、getcwd用于获取当前工作目录绝对路径，在设置环境的变量的时候它用的是绝对路径-所以也导致了在当前电脑上能用而移动后不能用。解决方法是在你的程序里重新设置下环境变量，而且是用相对路径的形式。
Java企业面试题3
m0_74972727的博客
09-15 834
1. break和continue的作用(智*图) break：用于完全退出一个循环（如 for, while）或一个 switch 语句。当在循环体内遇到break语句时，程序会立即跳出当前循环体，继续执行循环之后的代码。 continue：用于跳过当前循环体中剩余的部分，并开始下一次循环。如果是在 for 循环中使用continue，则会直接进行条件判断以决定是否执行下一轮循环。 2. if分支语句和switch分支语句的异同之处(智*图) 相同点：都是用来根据不同的条件执行不同的代码块。
Python——俄罗斯方块
2302_81225694的博客
09-14 2398
这段代码使用了Pygame库来实现游戏的图形界面，通过键盘控制方块的移动和旋转。游戏循环不断更新方块的位置和网格状态，并绘制在屏幕上。在方块达到底部或无法继续移动时，判断是否有满行，并清除满行的方块。游戏会根据方块的状态和移动情况不断更新，直到无法继续下落为止，游戏结束。俄罗斯方块游戏是一款经典的益智游戏，通常使用编程语言Python来实现。请注意，这只是一个简单的示例，可能还有一些功能和优化方面的改进。您可以根据自己的需求进行修改和扩展。
文档内容识别系统源码分享
xuehaishijue的博客
09-17 1656
数据集信息展示在当今信息爆炸的时代，文档内容识别系统的有效性和准确性愈发重要。为了提升YOLOv8在文档内容识别任务中的表现，我们采用了名为“FULL 2”的数据集进行训练和评估。该数据集专为文档图像的多样性和复杂性而设计，涵盖了多种类别的文本元素，使其成为优化深度学习模型的理想选择。
Python多线程Threading实战：子线程与守护线程解析
"Python多线程Threading、子线程与守护线程的实例解析，包括线程与进程的概念，Threading模块的使用，以及如何创建和管理线程，特别是子线程和守护线程的应用" 在Python编程中，多线程是一个关键的概念，它允许...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值