python 进程、线程、协程基本使用

    • 1、进程、线程以及协程
      • 【1】进程概念
      • 【2】线程的概念
        • 线程的生命周期
        • 进程与线程的区别
      • 【3】协程(Coroutines)
    • 2、多线程实现
      • 【1】threading模块
      • 【2】互斥锁
      • 【3】线程池
      • 【4】线程应用
    • 3、多进程实现
    • 4、协程实现
      • 【1】yield与协程
      • 【2】asyncio模块
      • 【3】3.8版本+
      • 【4】aiohttp

1. 并发与并行
2. IO密集型任务和计算密集型任务
3. 同步与异步
4. IO模型(IO多路复用)
5. 内核态多线程,用户态多线程

所谓并发编程是指在一台处理器上“同时”处理多个任务。并发是在同一实体上的多个事件**。强调多个事件在同一时间间隔发生。**

1、进程、线程以及协程

【1】进程概念

我们都知道计算机的核心是CPU,它承担了所有的计算任务;而操作系统是计算机的管理者,它负责任务的调度、资源的分配和管理,统领整个计算机硬件;应用程序则是具有某种功能的程序,程序是运行于操作系统之上的。

进程是一个具有一定独立功能的程序在一个数据集上的一次动态执行的过程,是操作系统进行资源分配和调度的一个独立单位,是应用程序运行的载体。

多道技术:空间复用+时间复用,于是有了进程!

进程是一种抽象的概念,从来没有统一的标准定义。进程一般由程序、数据集合和进程控制块三部分组成。

例子:我和我的女朋友们的故事我就是CPU,我跟三个女朋友玩就是三个任务1. 我教第一个女朋友做菜,菜谱就是程序,食材就是数据,我做饭的过程就是一个进程(切换,状态保存)2. 我给第二个女朋友治疗脚伤,医疗手册就是程序,医药箱就是数据,治疗脚伤的过程就是第二个进程。。。

进程状态反映进程执行过程的变化。这些状态随着进程的执行和外界条件的变化而转换。在三态模型中,进程状态分为三个基本状态,即运行态,就绪态,阻塞态。在五态模型中,进程分为新建态、终止态,运行态,就绪态,阻塞态。

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

【2】线程的概念

在早期的操作系统中并没有线程的概念,进程是能拥有资源和独立运行的最小单位,也是程序执行的最小单位。任务调度采用的是时间片轮转的抢占式调度方式,而进程是任务调度的最小单位,每个进程有各自独立的一块内存,使得各个进程之间内存地址相互隔离。后来,随着计算机的发展,对CPU的要求越来越高,进程之间的切换开销较大,已经无法满足越来越复杂的程序的要求了。于是就发明了线程。

线程是程序执行中一个单一的顺序控制流程,是程序执行流的最小单元,是处理器调度和分派的基本单位。

一个进程可以有一个或多个线程,各个线程之间共享程序的内存空间(也就是所在进程的内存空间)。一个标准的线程由线程ID、当前指令指针(PC)、寄存器和堆栈组成。而进程由内存空间(代码、数据、进程空间、打开的文件)和一个或多个线程组成。

线程的生命周期

当线程的数量小于处理器的数量时,线程的并发是真正的并发,不同的线程运行在不同的处理器上。但当线程的数量大于处理器的数量时,线程的并发会受到一些阻碍,此时并不是真正的并发,因为此时至少有一个处理器会运行多个线程。

在单个处理器运行多个线程时,并发是一种模拟出来的状态。操作系统采用时间片轮转的方式轮流执行每一个线程。现在,几乎所有的现代操作系统采用的都是时间片轮转的抢占式调度方式,如我们熟悉的Unix、Linux、Windows及macOS等流行的操作系统。

我们知道线程是程序执行的最小单位,也是任务执行的最小单位。在早期只有进程的操作系统中,进程有五种状态,创建、就绪、运行、阻塞(等待)、退出。早期的进程相当于现在的只有单个线程的进程,那么现在的多线程也有五种状态,现在的多线程的生命周期与早期进程的生命周期类似。

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

线程的生命周期# 创建:一个新的线程被创建,等待该线程被调用执行;
# 就绪:时间片已用完,此线程被强制暂停,等待下一个属于它的时间片到来;
# 运行:此线程正在执行,正在占用时间片;
# 阻塞:也叫等待状态,等待某一事件(如IO或另一个线程)执行完;
# 退出:一个线程完成任务或者其他终止条件发生,该线程终止进入退出状态,退出状态释放该线程所分配的资源。
进程与线程的区别

前面讲了进程与线程,但可能你还觉得迷糊,感觉他们很类似。的确,进程与线程有着千丝万缕的关系,下面就让我们一起来理一理:

  1. 线程是程序执行的最小单位,而进程是操作系统分配资源的最小单位;
  2. 一个进程由一个或多个线程组成,线程是一个进程中代码的不同执行路线;
  3. 进程之间相互独立,但同一进程下的各个线程之间共享程序的内存空间(包括代码段、数据集、堆等)及一些进程级的资源(如打开文件和信号),某进程内的线程在其它进程不可见;
  4. 调度和切换:线程上下文切换比进程上下文切换要快得多。

【3】协程(Coroutines)

协程(Co-routine),也可称为微线程,或非抢占式的多任务子例程,一种用户态的上下文切换技术(通过一个线程实现代码块间的相互切换执行)。这种由程序员自己写程序来管理的轻量级线程叫做『用户空间线程』,具有对内核来说不可见的特性。正如一个进程可以拥有多个线程一样,一个线程也可以拥有多个协程。

协程解决的是线程的切换和内存开销的问题

* 用户空间 首先是在用户空间, 避免内核态和用户态的切换导致的成本。
* 由语言或者框架层调度
* 更小的栈空间允许创建大量实例(百万级别)

2、多线程实现

【1】threading模块

Python提供两个模块进行多线程的操作,分别是threadthreading,前者是比较低级的模块,用于更底层的操作,一般应用级别的开发不常用。

import timedef foo():print("foo start...")time.sleep(5)print("foo end...")def bar():print("bar start...")time.sleep(3)print("bar end...")# 串行版本
# start = time.time()
# foo()
# bar()
# end = time.time()
# print("cost timer:", end - start)# 多线程并发版本import threadingstart = time.time()
t1 = threading.Thread(target=foo, args=())
t1.start()
t2 = threading.Thread(target=bar, args=())
t2.start()# 等待所有子线程结束
# t1.join()  # 等待子线程t1
# t2.join()  # 等待子线程t2
end = time.time()
print(end - start)

【2】互斥锁

import time
import threadingLock = threading.Lock()def addNum():global num  # 在每个线程中都获取这个全局变量# 上锁Lock.acquire()t = num - 1time.sleep(0.0001)num = tLock.release()# 放锁num = 100  # 设定一个共享变量thread_list = []for i in range(100):t = threading.Thread(target=addNum)t.start()thread_list.append(t)for t in thread_list:  # 等待所有线程执行完毕t.join()print('Result: ', num)

【3】线程池

系统启动一个新线程的成本是比较高的,因为它涉及与操作系统的交互。在这种情形下,使用线程池可以很好地提升性能,尤其是当程序中需要创建大量生存期很短暂的线程时,更应该考虑使用线程池。

线程池在系统启动时即创建大量空闲的线程,程序只要将一个函数提交给线程池,线程池就会启动一个空闲的线程来执行它。当该函数执行结束后,该线程并不会死亡,而是再次返回到线程池中变成空闲状态,等待执行下一个函数。

此外,使用线程池可以有效地控制系统中并发线程的数量。当系统中包含有大量的并发线程时,会导致系统性能急剧下降,甚至导致解释器崩溃,而线程池的最大线程数参数可以控制系统中并发线程的数量不超过此数。

import time
from concurrent.futures import ThreadPoolExecutordef task(i):print(f'任务{i}开始!')time.sleep(i)print(f'任务{i}结束!')return istart = time.time()
pool = ThreadPoolExecutor(3)future01 = pool.submit(task, 1)
# print("future01是否结束", future01.done())
# 当程序使用 Future 的 result() 方法来获取结果时,该方法会阻塞当前线程,如果没有指定 timeout 参数,当前线程将一直处于阻塞状态,直到 Future 代表的任务返回。
# print("future01的结果", future01.result())  # 同步等待
future02 = pool.submit(task, 2)
future03 = pool.submit(task, 3)
pool.shutdown()  # 阻塞等待
print(f"程序耗时{time.time() - start}秒钟")print("future01的结果", future01.result())
print("future02的结果", future02.result())
print("future03的结果", future03.result())

使用线程池来执行线程任务的步骤如下:

  1. 调用 ThreadPoolExecutor 类的构造器创建一个线程池。
  2. 定义一个普通函数作为线程任务。
  3. 调用 ThreadPoolExecutor 对象的 submit() 方法来提交线程任务。
  4. 当不想提交任何任务时,调用 ThreadPoolExecutor 对象的 shutdown() 方法来关闭线程池。

【4】线程应用

import requests
from lxml import etree
import os
import asyncio
import time
import threadingdef get_img_urls():res = requests.get("https://www.pkdoutu.com/photo/list/", headers={"User-Agent": "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/110.0.0.0 Safari/537.36"})selector = etree.HTML(res.text)img_urls = selector.xpath('//li[@class="list-group-item"]/div/div/a/img[@data-backup]/@data-backup')print(img_urls)return img_urlsdef save_img(url):res = requests.get(url)name = os.path.basename(url)with open("imgs/" + name, "wb") as f:f.write(res.content)print(f"{name}下载完成!")def main():img_urls = get_img_urls()# 串行[save_img(url) for url in img_urls]# 协程并发t_list = []for url in img_urls:t = threading.Thread(target=save_img, args=(url,))t.start()t_list.append(t)for t in t_list:t.join()if __name__ == '__main__':start = time.time()main()end = time.time()print(end - start)

针对IO密集型任务,Python多线程可以发挥出不错的并发作用

3、多进程实现

由于GIL的存在,python中的多线程其实并不是真正的多线程,如果想要充分地使用多核CPU的资源,在python中大部分情况需要使用多进程。

multiprocessing包是Python中的多进程管理包。与threading.Thread类似,它可以利用multiprocessing.Process对象来创建一个进程。该进程可以运行在Python程序内部编写的函数。该Process对象与Thread对象的用法相同,也有start(), run(), join()的方法。此外multiprocessing包中也有Lock/Event/Semaphore/Condition类 (这些对象可以像多线程那样,通过参数传递给各个进程),用以同步进程,其用法与threading包中的同名类一致。所以,multiprocessing的很大一部份与threading使用同一套API,只不过换到了多进程的情境。

python的进程调用:

import multiprocessing
import timedef foo():print("foo start...")time.sleep(5)print("foo end...")def bar():print("bar start...")time.sleep(3)print("bar end...")if __name__ == '__main__':start = time.time()t1 = multiprocessing.Process(target=foo, args=())t1.start()t2 = multiprocessing.Process(target=bar, args=())t2.start()# 等待所有子线程结束t1.join()  # 等待子线程t1t2.join()  # 等待子线程t2end = time.time()print(end - start)

4、协程实现

协程,又称微线程,纤程。英文名Coroutine。一句话说明什么是线程:协程是一种用户态的轻量级线程。

协程拥有自己的寄存器上下文和栈。协程调度切换时,将寄存器上下文和栈保存到其他地方,在切回来的时候,恢复先前保存的寄存器上下文和栈。因此:

协程能保留上一次调用时的状态(即所有局部状态的一个特定组合),每次过程重入时,就相当于进入上一次调用的状态,换种说法:进入上一次离开时所处逻辑流的位置。

【1】yield与协程


def foo():print("OK1")yield 100  # 切换: 保存/恢复的功能print("OK2")yield 1000def bar():print("OK3")yield 200print("OK4")yield 2000gen = foo()
ret = next(gen)    # gen.__next__()
print(ret)gen2 = bar()
ret2 = next(gen2)  # gen.__next__()
print(ret2)ret = next(gen)    # gen.__next__()
print(ret)ret2 = next(gen2)  # gen.__next__()
print(ret2)

【2】asyncio模块

asyncio即Asynchronous I/O是python一个用来处理并发(concurrent)事件的包,是很多python异步架构的基础,多用于处理高并发网络请求方面的问题。

为了简化并更好地标识异步IO,从Python 3.5开始引入了新的语法async和await,可以让coroutine的代码更简洁易读。

asyncio 被用作多个提供高性能 Python 异步框架的基础,包括网络和网站服务,数据库连接库,分布式任务队列等等。

asyncio 往往是构建 IO 密集型和高层级 结构化 网络代码的最佳选择。

import asyncioasync def task(i):print(f"task {i} start")await asyncio.sleep(1)print(f"task {i} end")# 创建事件循环对象
loop = asyncio.get_event_loop()
# 直接将协程对象加入时间循环中
tasks = [task(1), task(2)]
# asyncio.wait:将协程任务进行收集,功能类似后面的asyncio.gather
# run_until_complete阻塞调用,直到协程全部运行结束才返回
loop.run_until_complete(asyncio.wait(tasks))
loop.close()

task: 任务,对协程对象的进一步封装,包含任务的各个状态;asyncio.Task是Future的一个子类,用于实现协作式多任务的库,且Task对象不能用户手动实例化,通过下面2个函数loop.create_task() 或 asyncio.ensure_future()创建。

import asyncio, timeasync def work(i, n):  # 使用async关键字定义异步函数print('任务{}等待: {}秒'.format(i, n))await asyncio.sleep(n)  # 休眠一段时间print('任务{}在{}秒后返回结束运行'.format(i, n))return i + nstart_time = time.time()  # 开始时间tasks = [asyncio.ensure_future(work(1, 1)),asyncio.ensure_future(work(2, 2)),asyncio.ensure_future(work(3, 3))]loop = asyncio.get_event_loop()
loop.run_until_complete(asyncio.wait(tasks))
loop.close()print('运行时间: ', time.time() - start_time)
for task in tasks:print('任务执行结果: ', task.result())

【3】3.8版本+

async.run() 运行协程
async.create_task()创建task
async.gather()获取返回值


import asyncio, timeasync def work(i, n):  # 使用async关键字定义异步函数print('任务{}等待: {}秒'.format(i, n))await asyncio.sleep(n)  # 休眠一段时间print('任务{}在{}秒后返回结束运行'.format(i, n))return i + ntasks = []
async def main():global taskstasks = [asyncio.create_task(work(1, 1)),asyncio.create_task(work(2, 2)),asyncio.create_task(work(3, 3))]await asyncio.wait(tasks) # 阻塞start_time = time.time()  # 开始时间
asyncio.run(main())
print('运行时间: ', time.time() - start_time)
for task in tasks:print('任务执行结果: ', task.result())

asyncio.create_task() 函数在 Python 3.7 中被加入。

asyncio.gather方法

# 用gather()收集返回值import asyncio, timeasync def work(i, n):  # 使用async关键字定义异步函数print('任务{}等待: {}秒'.format(i, n))await asyncio.sleep(n)  # 休眠一段时间print('任务{}在{}秒后返回结束运行'.format(i, n))return i + nasync def main():tasks = [asyncio.create_task(work(1, 1)),asyncio.create_task(work(2, 2)),asyncio.create_task(work(3, 3))]# 将task作为参数传入gather,等异步任务都结束后返回结果列表response = await asyncio.gather(tasks[0], tasks[1], tasks[2])print("异步任务结果:", response)start_time = time.time()  # 开始时间asyncio.run(main())print('运行时间: ', time.time() - start_time)

【4】aiohttp

我们之前学习过爬虫最重要的模块requests,但它是阻塞式的发起请求,每次请求发起后需阻塞等待其返回响应,不能做其他的事情。本文要介绍的aiohttp可以理解成是和requests对应Python异步网络请求库,它是基于 asyncio 的异步模块,可用于实现异步爬虫,有点就是更快于 requests 的同步爬虫。安装方式,pip install aiohttp。

aiohttp是一个为Python提供异步HTTP 客户端/服务端编程,基于asyncio的异步库。asyncio可以实现单线程并发IO操作,其实现了TCP、UDP、SSL等协议,aiohttp就是基于asyncio实现的http框架。

import aiohttp
import asyncioasync def main():async with aiohttp.ClientSession() as session:async with session.get("http://httpbin.org/headers") as response:print(await response.text())asyncio.run(main())

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处:http://www.mzph.cn/news/783528.shtml

如若内容造成侵权/违法违规/事实不符,请联系多彩编程网进行投诉反馈email:809451989@qq.com,一经查实,立即删除!

相关文章

网络基础(二)——序列化与反序列化

目录 1、应用层 2、再谈“协议” 3、网络版计算器 Socket.hpp TcpServer.hpp ServerCal.hpp ServerCal.cc Protocol.hpp ClientCal.cc Log.hpp Makefile 1、应用层 我们程序员写的一个个解决我们实际问题,满足我们日常需求的网络程序,都是在…

AtCode DP专练A-P

链接:Educational DP Contest - AtCoder A - Frog 1 题意:有n个石头,从1石头出发,每次可以跳一格或者俩格,代价为俩个格子间的高度差 思路:对于第i个石头,可以从石头i-1和i-2得到&#xff0c…

31.Python从入门到精通—Python数据压缩 性能度量 测试模块

31.从入门到精通:Python数据压缩 性能度量 测试模块 个人简介数据压缩性能度量测试模块 个人简介 🏘️🏘️个人主页:以山河作礼。 🎖️🎖️:Python领域新星创作者,CSDN实力新星认证&#xff0c…

分类预测 | MATLAB实现BO-CNN-LSTM贝叶斯优化卷积长短期记忆网络多输入分类预测

分类预测 | MATLAB实现BO-CNN-LSTM贝叶斯优化卷积长短期记忆网络多输入分类预测 目录 分类预测 | MATLAB实现BO-CNN-LSTM贝叶斯优化卷积长短期记忆网络多输入分类预测效果一览基本介绍模型搭建程序设计参考资料 效果一览 基本介绍 MATLAB实现BO-CNN-LSTM贝叶斯优化卷积长短期记…

深度好文:解决Ubuntu 18.04安装nvidia显卡驱动,导致内核不匹配:无需重装系统修复内核

深度好文:解决Ubuntu 18.04安装nvidia显卡驱动,导致内核不匹配:无需重装系统修复内核 目录 一、问题描述二、尝试修复三、安装Nvidia驱动和CUDA并配置cuDNN四、总结 一、问题描述 昨天打算更新一下Ubuntu 18.04的显卡驱动,以支持…

Eclipse新建java类的操作流程

一、在左侧空白区域,点击鼠标右键。 二、点击new,选择Java Project (由于这里不知道怎么截图,就用手机拍了一张,希望不要介意) 三、 给project文件起个名字,其他都不用管,点击Finis…

云防护是怎么能帮助用户做好网络安全

在数字化时代,网络安全威胁呈现出愈发复杂和多样化的趋势。 无论是个人用户、小型企业还是大型企业,都面临着来自全球各地的网络攻击风险。这些攻击可能导致数据泄露、服务中断、财务损失甚至声誉受损。因此,采取有效的安全防护措施变得至关…

HarmonyOS 应用开发之Stage模型启动FA模型PageAbility

本小节介绍Stage模型的两种应用组件如何启动FA模型的PageAbility组件。 UIAbility启动PageAbility UIAbility启动PageAbility和UIAbility启动UIAbility的方式完全相同。 说明: 需注意FA模型中abilityName由bundleName AbilityName组成,具体见示例。 i…

不允许你不知道的 MySQL 优化实战(一)

文章目录 1、查询SQL尽量不要使用select *,而是select具体字段。2、如果知道查询结果只有一条或者只要最大/最小一条记录,建议用limit 13、应尽量避免在where子句中使用or来连接条件4、优化limit分页5、优化你的like语句6、使用where条件限定要查询的数据…

uniapp开发App(二)开通 微信授权登录功能(应用签名、证书、包名 全明白)

前言:开发App肯定要包含登陆,常用登陆方式很多,我选择微信登陆。 一、如何获得微信的授权登陆 答:申请,根据uniapp官网的提示有如下三个步骤 开通 1. 登录微信开放平台区,添加移动应用并提交审核&#xf…

C语言中的文件和文件操作

目录 为什么会有文件? 文件名 ⼆进制⽂件和⽂本⽂件? ⽂件的打开和关闭 流 标准流 ⽂件指针 ⽂件的打开和关闭 顺序读写函数介绍 对⽐⼀组函数: 文件的随机读写 fseek ftell rewind ⽂件读取结束的判定 被错误使⽤的 feof ⽂件…

PCL点云处理之重复随机采样一致性(RRANSAC法)平面拟合(二百三十七)

PCL点云处理之重复随机采样一致性(RRANSAC法)平面拟合(二百三十七) 一、算法介绍二、算法实现1.代码2.结果一、算法介绍 pcl::SAC_RRANSAC"是 PCL库中的一个方法,是 RANSAC 方法的改进版本,通过多次重复采样和模型拟合来提高鲁棒性。RRANSAC 的思想是在 RANSAC 的基…

基于深度学习的图书管理推荐系统(python版)

基于深度学习的图书管理推荐系统 1、效果图 1/1 [] - 0s 270ms/step [13 11 4 19 16 18 8 6 9 0] [0.1780757 0.17474999 0.17390694 0.17207369 0.17157653 0.168248440.1668652 0.16665359 0.16656876 0.16519257] keras_recommended_book_ids深度学习推荐列表 [9137…

Windows提权!!!

之前讲过一下提权,但是感觉有点不成体系,所以我们就成体系的来讲一下这个操作系统的提权 目录 Windows的提权 1.Widnows的内核溢出提权 1.MSF自带的提权模块(Win11都能提上来,有点牛逼) 2.CS的插件提权 3.补丁对比…

透视未来安全:PIR技术引领数据隐私新时代

1.隐语实现PIR总体介绍 隐语实现的Private Information Retrieval (PIR) 是一种隐私增强技术,它使用户能够在不暴露他们实际查询内容的情况下从远程服务器数据库中检索所需信息。以下是隐语在实现PIR方面的概要说明和技术特点: 基本概念: PI…

【蓝桥杯】矩阵快速幂

一.快速幂概述 1.引例 1)题目描述: 求A^B的最后三位数表示的整数,A^B表示:A的B次方。 2)思路: 一般的思路是:求出A的B次幂,再取结果的最后三位数。但是由于计算机能够表示的数字…

[linux初阶][vim-gcc-gdb] TwoCharter: gcc编译器

目录 一.Linux中gcc编译器的下载与安装 二.使用gcc编译器来翻译 C语言程序 ①.编写C语言代码 ②翻译C语言代码 a.预处理 b.编译 c.汇编 d.链接 ③.执行Main 二进制可执行程序(.exe文件) 三.总结 一.Linux中gcc编译器的下载与安装 使用yum命令(相当于手机上的应用…

10_MVC

文章目录 JSON常用的JSON解析Jackson的常规使用指定日期格式 MVC设计模式MVC介绍前后端分离案例(开发与Json相关接口) 三层架构三层架构介绍 JSON JSON(JavaScript Object Notation) 是一种轻量级的数据交换格式,是存…

JUC并发编程(七)

1、不可变对象 1.1、概念 不可变类是指一旦创建对象实例后,就不能修改该实例的状态。这意味着不可变类的对象是不可修改的,其内部状态在对象创建后不能被更改。不可变类通常具有以下特征: 实例状态不可改变:一旦不可变类的对象被…

unordered系列容器OJ

目录 1、unordered系列容器 2、unordered系列容器OJ 1、重复n次的元素 2、两个数组的交集I 3、两个数组的交集II 4、存在重复元素 5、两句话中不常见的单词 1、unordered系列容器 在C标准库中,unordered系列容器是基于哈希表实现的, 用于存储唯一…