Day05 Python中的线程、互斥锁等

最新推荐文章于 2024-06-21 12:33:31 发布
最新推荐文章于 2024-06-21 12:33:31 发布
阅读量753 收藏
点赞数
分类专栏： Python 文章标签： python
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_50036611/article/details/124390457
版权

一、多任务

1、多任务的定义

多种任务同时进行

2、多任务的执行方式

1.并发：多个任务在同一时间段内串行交替执行。

2.并行：多个任务在同一时刻内相互独立且同时执行。
在这里插入图片描述

二、多线程

Pass：说道线程，必须要首先介绍一下进程是什么？

进程：

  • 运行的程序或软件，它是操作系统进行资源分配的基本单位；比如我们运行的.py文件就是一个进程；
  • 一个进程默认有一个线程，进程里可以创建多个线程，线程是依附在进程里的，没有进程就没有线程。

1、线程的定义

是进程中执行代码的一个分支，每个执行分支要想工作执行代码，需要cpu进行调度，也就是说线程是cpu调度的基本单位。

用下面的图帮助我们去了解进程与线程之间的关系：

在这里插入图片描述

2、创建单线程

例1：

import time
def question():
    print('夏天到了')
    time.sleep(1)
    print('大家都开空调了吗？')
def answer():
    print('哈哈')
    time.sleep(2)
    print('那是当然的了！')
if __name__ =='__main__': # python模拟的程序入口，表示直接运行时，执行里面的代码
    question()
    answer()


 **结果**：
夏天到了
（中间停留1s）
大家都开空调了吗？
哈哈
(中间停留2s)
那是当然的了！

例2：

import time
def dance(name):
    print(f'{name}在跳See ya')
    time.sleep(4)
if __name__=='__main__':
    for i in range(2):
        dance('任嘉伦')#调用dance函数，并且name=任嘉伦


**结果**：
任嘉伦在跳See ya
（中间停留4s）
任嘉伦在跳See ya

3、创建多线程

1.步骤：

  • 1.导入模块 threading
  • 2.创建子线程 Thread类
  • 3.可设置守护线程 setDaemon() 主线程执行完了，子线程也会跟着结束
  • 4.启动子线程 start()
  • 5.可设置阻塞主线程 join() 阻塞主线程，等待子线程执行完

例1：多进程

import threading#导入进程方式1
import time
def dance(name):
    print(f'{name}在跳See ya')
    time.sleep(1)
if __name__ == '__main__':
    for i in range(2):
        # 创建线程
        t = threading.Thread(target=dance,args=('任嘉伦',))
        #启动线程
        t.start()


结果：
任嘉伦在跳See ya
（中间间隔非常短）
任嘉伦在跳See ya

例2：多线程进阶，添加守护线程

import time
from threading import Thread#导入线程方式2
def f1():
    print('任嘉伦')
    time.sleep(1)
    print('任嘉伦是我的偶像')
def f2():
    print('好好学习')
    time.sleep(1)
    print('你就能见他了！')
if __name__=='__main__':
    # 创建线程
    f1 = Thread(target=f1)
    f2 = Thread(target=f2)
    # 设置守护线程
    f1.setDaemon(True)
    f2.setDaemon(True)
    # 启动线程
    f1.start()
    f2.start()
    print('哈哈！')

结果：
任嘉伦  
（f1中的“任嘉伦是我的偶像”还没执行，主线程就先执行完了）
好好学习 
（f2中的“你就能见他了！”还没有执行，主线程就先执行完了）
哈哈！

例3：多线程进阶，添加阻塞主线程，不添加守护线程

import time
from threading import Thread
def f1():
    print('任嘉伦')
    time.sleep(0.1)
    print('任嘉伦是我的偶像')
def f2():
    print('好好学习')
    time.sleep(2)
    print('你就能见他了！')
if __name__ == '__main__':
    # 创建线程
    f1 = Thread(target=f1)
    f2 = Thread(target=f2)
    # 启动线程
    f1.start()
    f2.start()
    # 阻塞主线程----"我(主线程）等你(子线程)"
    f1.join()
    f2.join()
    print('哈哈！')

# 结果：
# 任嘉伦
# 好好学习
# 任嘉伦是我的偶像
# 你就能见他了！
# 哈哈！

例4：多线程进阶，添加阻塞主线程，添加守护线程

import time
from threading import Thread
def f1():
    print('任嘉伦')
    time.sleep(0.1)
    print('任嘉伦是我的偶像')
def f2():
    print('好好学习')
    time.sleep(2)
    print('你就能见他了！')
if __name__ == '__main__':
    # 创建线程
    f1 = Thread(target=f1)
    f2 = Thread(target=f2)
    # 设置守护线程
    f1.setDaemon(True)
    f2.setDaemon(True)
    # 启动线程
    f1.start()
    f2.start()
    # 阻塞主线程----"我(主线程）等你(子线程)"
    f1.join()
    f2.join()
    print('哈哈！')

# 结果：
# 任嘉伦
# 好好学习
# 任嘉伦是我的偶像
# 你就能见他了！
# 哈哈！

例5：多线程进阶，修改名字和获取名字

import time
from threading import Thread
def f1():
    print('任嘉伦')
    time.sleep(1)
    print('任嘉伦是我的偶像')
def f2():
    print('好好学习')
    time.sleep(2)
    print('你就能见他了！')

if __name__ == '__main__':
    # 创建线程
    f1 = Thread(target=f1)
    f2 = Thread(target=f2)
    # 启动线程
    f1.start()
    f2.start()
    # 阻塞主线程----"我(主线程）等你(子线程)"
    f1.join()
    f2.join()
    # 修改名字
    f1.setName('Allen')
    f2.setName('任国超')
    # 获取名字
    print(f1.getName())
    print(f2.getName())
    print('哈哈！')


#结果：
# 任嘉伦
# 好好学习
# 任嘉伦是我的偶像
# 你就能见他了！
# Allen
# 任国超
# 哈哈！

2.线程执行代码的封装

from threading import Thread
import time
class Ourthread(Thread):
    # 重写run方法
    def run(self):
        print('任嘉伦')
        time.sleep(7)
        print('你们认识吗？')
if __name__ == '__main__':
    t1 = Ourthread()
    t1.start()

结果：
任嘉伦
你们认识吗？

3.结论

结论1：线程之间执行是无序的"

import threading    # 导入线程模块
import time
def task():
    time.sleep(2)
    print(f'当前线程名为:{threading.current_thread().name}\n', end='')
    # print(f'当前线程名为:{threading.current_thread().name}\n',end='')

if __name__ == '__main__':
    for i in range(3):
        # 创建线程
        t = threading.Thread(target=task)
        # 启动线程
        t.start()



# 结果：执行第1次
# 当前线程名为:Thread-1
# 当前线程名为:Thread-3
# 当前线程名为:Thread-2

# 执行第2次：
# 当前线程名为:Thread-1
# 当前线程名为:Thread-2
# 当前线程名为:Thread-3

结论2：多线程资源共享

from threading import Thread   # 导入线程模块的另一种方式
import time
list = []   # 全局变量，空列表
# 写数据
def writedata():
    for i in range(5):
        list.append(i)   # 添加i到lst列表
        time.sleep(0.2) # 睡眠0.2s
    print('写入数据：',list)

# 读数据
def readdata():
    print('读取的数据：',list)

if __name__ == '__main__':
    # 创建线程
    wd = Thread(target=writedata)
    rd = Thread(target=readdata)
    # 启动线程
    wd.start()
    rd.start()
# 结果：
# 读取的数据： [0]（写数据还没写完，就读取了）
# 写入数据： [0, 1, 2, 3, 4]

结论3：线程之间存在资源竞争

from threading import Thread
a = 0
b = 1000000
def sum1():
    for i in range(b):
        global a
        a += 1
    print(f'第一次：{a}\n',end='')

def sum2():
    for i in range(b):
        global a
        a += 1
    print(f'第二次：{a}\n',end='')
# sum2()
if __name__ == "__main__":
    # 创建线程
    t1 = Thread(target=sum1)
    t2 = Thread(target=sum2)
    # 启动线程
    t1.start()
    t2.start()

# 结果：
# 第二次：1549492
# 第一次：1680705

Pass：资源竞争有什么解决的办法呢？

三、 互斥锁

资源竞争解决的办法 ：互斥锁
1、定义：
在这里插入图片描述
普通的，不使用线程：

a = 0
b = 1000000

def sum1():
    for i in range(b):
        global a
        a += 1
    print(f'第一次：{a}\n',end='')
sum1()#

def sum2():

    for i in range(b):
        global a
        a += 1
    print(f'第二次：{a}\n',end='')
sum2()

结果：
第一次：1000000
第二次：2000000

使用进程，互斥锁解决：

from threading import Thread,Lock
a = 0
b = 1000000
# 创建全局互斥锁
lock = Lock()
def sum1():
    lock.acquire()    # 加锁   
    for i in range(b):
        global a
        a += 1
    print(f'第一次：{a}\n',end='')
    lock.release()   # 解锁
# sum1()
def sum2():
    lock.acquire()
    for i in range(b):
        global a
        a += 1
    print(f'第二次：{a}\n',end='')
    lock.release()
    
if __name__ == "__main__":
    # 创建线程
    t1 = Thread(target=sum1)
    t2 = Thread(target=sum2)
    # 启动线程
    t1.start()
    t2.start()

结果：
第一次：1000000
第二次：2000000

四、同步

1、定义：
在这里插入图片描述
使用join()解决：

from threading import Thread
a = 0
b = 1000000

def sum1():
    for i in range(b):
        global a
        a += 1
    print(f'第一次：{a}\n',end='')

def sum2():

    for i in range(b):
        global a
        a += 1
    print(f'第二次：{a}\n',end='')

if __name__ == "__main__":
    # 创建线程
    t1 = Thread(target=sum1)
    t2 = Thread(target=sum2)
    # 启动线程
    t1.start()
    t1.join()   # 解决资源竞争join()方式
    t2.start()
    t2.join()

结果：
第一次：1000000
第二次：2000000
小菜鸟也要努力吖
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
对python多线程中互斥锁Threading.Lock的简单应用详解
09-19
Python中的多线程是并发执行任务的有效方式，但线程间的资源共享可能会引发竞态条件，导致数据不一致或错误的结果。这就是所谓的“线程不安全”。为了确保在多线程环境中正确地访问共享资源，我们可以使用互斥锁...
Python Threading 线程/互斥锁/死锁/GIL锁
09-19
总的来说，Python Threading 提供了基本的多线程功能，但需要注意互斥锁的使用以防止数据错误和死锁，同时理解 GIL 对多线程的影响以及如何在适当情况下规避它的限制。正确理解和应用这些概念将有助于编写高效且并发...
Python: 多线程与互斥锁
fengbohello的专栏
11-24 1269
目录 一、在 Python 使用多线程 二、互斥锁&防止死锁 一、在 Python 使用多线程 import threading import time import random class MyThread(threading.Thread): def __init__(self, name, mutex, arg): threading.Thread.__init__(self, daemon=True) self.name = name
Day 17 17.2 多线程实现之互斥锁
Chimengmeng的博客
03-19 83
多线程实现之互斥锁 问题引入 假如存在一个列表： A线程对其修改，B进程对其访问 假如A，B线程同时去修改和访问则会出现问题 一个数据明明要被A线程删掉的，结果B线程抢先一步就把这个数据访问到了 那么如何解决这个问题呢？可以使用线程同步 1.1 线程同步： 多个线程访问一个对象时，请线程们先排好队，一个一个使用 1.2 互斥锁 可以使用互斥锁来实现线程同步。 互斥锁的...
Day 35 守护线程，互斥锁
A1L__的博客
08-25 148
Day 02 为什么要有线程 进程的缺点 进程只能在一个时间干一件事，如果想同时干两件事或多件事，进程就无能为力了。 进程在执行的过程中如果阻塞，例如等待输入，整个进程就会挂起，即使进程中有些工作不依赖于输入的数据，也将无法执行。 生产者消费者模型 ​ 生产者消费者模式是通过·一个容器来解决生产者和消费者的强耦合问题 ​ 生产者和消费者彼此之间不能直接通讯，而通过阻塞队列来进行通讯，所以生产者生产完数据之后不用等待消费者处理，直接扔给阻塞队列，消费者不找生产者要数据，而是直接从阻塞队列里取 ​ 阻塞队列
python-day36_ 线程 多线程 守护线程 线程互斥锁 线程的并发 joinablequeue
weixin_30339457的博客
06-04 95
1 joinablequeue from multiprocessing import JoinableQueue # join 是等待某个任务运行完毕 able是可以的意思 Queue是队列 综合起来 就是一个可以被join的队列 继承自Queue j = JoinableQueue() # j.put('123') # 放入信息 # print(j.get())...
Python - 线程锁 - 进阶之路 - Day09
lixiang5453的博客
11-24 73
GIL(全局解释器锁) GIL并不是Python的特性，它是在实现Python解析器(CPython)时所引入的一个概念，是为了实现不同线程对共享资源访问的互斥，才引入了GIL 在Cpython解释器中，同一个进程下开启的多线程，同一时刻只能有一个线程执行，无法利用多核优势 python对于计算密集型的任务开多线程的效率甚至不如串行(没有大量切换)，但是，对于IO密集型的任务效率还是有显著提升的。 GIL原理图 计算密集型：结果肯定是100，因为每一次start结果就已经出来了，所以.
铁乐学python_Day42_线程锁和队列
夏虫不可语冰
05-23 334
铁乐学python_Day42_锁和队列 例：多个线程抢占资源的情况 from threading import Thread import time def work(): global n temp = n time.sleep(0.1) n = temp - 1 if __name__ == '__main__': n = 100 l...
Python Day 36:JoinableQueue队列/线程/线程互斥锁/死锁/递归锁/信号量
weixin_30491641的博客
06-09 82
## 守护进程 ```python def task(name=None,age=None): print("子进程为守护进程") time.sleep(5) print("守护结束",name,age) if __name__=="__main__": print("父进程开始") p=Process(target=ta...
逆袭之路——python 网络编程之进程的创建及属性方法、互斥锁【day35】
絵飛ヾ的魚的博客
04-19 435
今日内容概要 代码创建进程 multiprocess模块与multiprocess.process模块 join方法 进程间数据默认隔离 进程对象属性和方法 僵尸进程与孤儿进程 守护进程 互斥锁(重要) 今日内容详细 一、代码创建进程         对于通用系统（跑很多应用程序），需要有系统运行过程中创建或撤销进程的能力，主要分为4中形式创建新的进程： 系统初始化（查看进程linux中用ps命令，windows中用任
day38 生产者消费者模型、线程的两种开启方式、join、线程互斥锁、GIL
xiaoyurainzi的博客
08-25 154
目录1 生产者消费者模型2 线程理论3 开启线程的两种方式4 线程对象join方法5 同一个进程下的多个线程数据共享6 线程对象及其他方法7 线程互斥锁8 GIL全局解释器锁理论 1 生产者消费者模型 # 1 理论： -生产者消费者模式是通过一个容器来解决生产者和消费者的强耦合问题。 -生产者和消费者彼此之间不直接通讯，而通过阻塞队列来进行通讯，所以生产者生产完数据之后不用等待消费者处理，直接扔给阻塞队列，消费者不找生产者要数据，而是直接从阻塞队列里取 -阻塞队列就相当于一个缓冲区，平衡了
Python多线程操作之互斥锁、递归锁、信号量、事件实例详解
09-17
主要介绍了Python多线程操作之互斥锁、递归锁、信号量、事件,结合实例形式详细分析了Python多线程操作互斥锁、递归锁、信号量、事件相关概念、原理、用法与操作注意事项,需要的朋友可以参考下
Python多线程编程（四）：使用Lock互斥锁
09-22
在Python中，可以通过`threading.Lock()`创建一个互斥锁对象。当一个线程获得了锁，其他试图获取相同锁的线程会被阻塞，直到持有锁的线程释放它。这样，就确保了对共享资源的访问是串行化的，避免了竞态条件和数据不...
Python实现的多线程同步与互斥锁功能示例
09-21
主要介绍了Python实现的多线程同步与互斥锁功能,涉及Python多线程及锁机制相关操作技巧,需要的朋友可以参考下
Ubuntu 18.04 安装 PCL 1.14.1
最新发布
u014374826的博客
06-21 522
Ubuntu 18.04 安装 PCL 1.14.1
2024 年最新基于 LLOneBot NT 框架搭建 QQ 机器人详细教程（更新中）
唤醒手腕的博客
06-14 819
llonebot（LLOneBot）是一个与OneBot（也称为CQHTTP）协议兼容的机器人框架，它允许开发者使用不同的编程语言（如Python、Go、JavaScript等）编写机器人应用，并与各种支持 OneBot 协议的聊天平台（如QQ、Telegram、Discord等）进行交互。onebot 11 背景。
第9章 类
我走的每一步都算数
06-17 988
让一个类继承另一个类后，就可以添加区分子类和父类所需的新属性和新方法了。class Car:class ElectricCar(Car): # 继承Carself.battery = 85 # 新属性mycar = ElectricCar(2024, 'Au', 'A7') # 创建实例mycar.prt_battery() # 新方法熟悉Python 提供的选项，这样才能确定哪种组织方式是最佳的，并能理解别人开发的项目。
基于自编码器的心电图信号异常检测（Python）
weixin_39402231的博客
06-17 538
使用的数据集来自PTB心电图数据库，包括14552个心电图记录，包括两类：正常心跳和异常心跳，采样频率为125Hz。
python 多线程 互斥锁
02-21
互斥锁（Lock）是Python多线程编程中用于保护共享资源的一种机制。它可以确保在同一时刻只有一个线程可以访问共享资源，从而避免数据竞争和数据不一致的问题。 以下是一个使用互斥锁的示例代码： ```python import...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值