进程+线程+协程

已于 2024-09-23 20:37:06 修改
阅读量478 收藏 4
点赞数 9
分类专栏： Python 文章标签： python
于 2024-09-05 16:10:02 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_35732321/article/details/141933615
版权

进程+线程+协程


pip cache purge

1 进程

1.1 无进程

不使用进程，task_01和task_02先后执行


import os
import time
from  multiprocessing import Process

def task_01():
    print("*"*8+' task_01 '+"*"*8)
    i = 0
    while True:
        time.sleep(0.5)
        print('task_01:  %d'%i)
        i += 1
        if i>10:
            break

def task_02():
    print("*"*8+' task_02 '+"*"*8)
    i = 0
    while True:
        time.sleep(1)
        print('task_02:  %d'%i)
        i += 10
        if i>30:
            break


if __name__ == '__main__':
    print("*"*8+' 主程序开始 '+"*"*8)
    task_01()
    task_02()
    print("#" * 8 + ' 主程序结束 ' + "#" * 8)
‘’‘
## 运行结果
******** 主程序开始 ********
******** task_01 ********
task_01:  0
task_01:  1
task_01:  2
task_01:  3
task_01:  4
task_01:  5
task_01:  6
task_01:  7
task_01:  8
task_01:  9
task_01:  10
******** task_02 ********
task_02:  0
task_02:  10
task_02:  20
task_02:  30
######## 主程序结束 ########
Process finished with exit code 0
‘’‘

1.2 多进程

父程序和子程序各自执行，互不干扰。由于只有一个核，task_01和task_02交替执行。

import os
import time
from  multiprocessing import Process

def task_01():
    print("*"*8+' task_01 '+"*"*8)
    i = 0
    while True:
        time.sleep(0.5)
        print('task_01:  %d'%i)
        i += 1
        if i>10:
            break

def task_02():
    print("*"*8+' task_02 '+"*"*8)
    i = 0
    while True:
        time.sleep(1)
        print('task_02:  %d'%i)
        i += 10
        if i>100:
            break


if __name__ == '__main__':
    print("*"*8+' 主程序开始 '+"*"*8)
    p1 = Process(target = task_01,name="任务1")  # 子程序实例化
    p2 = Process(target = task_02,name="任务2")
    p1.start()   # 开启子程序
    p2.start()
    print("#" * 8 + ' 主程序结束 ' + "#" * 8)

## 运行结果
'''
******** 主程序开始 ********
######## 主程序结束 ########
******** task_01 ********
******** task_02 ********
task_01:  0
task_02:  0
task_01:  1
task_01:  2
task_02:  10
task_01:  3
task_01:  4
task_02:  20
task_01:  5
task_01:  6
task_02:  30
task_01:  7
task_01:  8
task_02:  40
task_01:  9
task_01:  10
task_02:  50
task_02:  60
task_02:  70
task_02:  80
task_02:  90
task_02:  100

Process finished with exit code 0
'''

1.3 p1.join()

p1.join() 表示主进程要等子进程执行完再执行p1.join()后面的代码

# 
import os
import time
from  multiprocessing import Process

def task_01(name,s):
    print("*"*8+' task_01 '+"*"*8)
    i = 0
    while True:
        time.sleep(s)
        print(' %s:  task_01.id: %d, i:  %d'%(name,os.getpid(),i))
        i += 1
        if i>40:
            break

def task_02(name,s):
    print("*"*8+' task_02 '+"*"*8)
    j = 0
    while True:
        time.sleep(s)
        print(' %s:  task_02.id: %d, j:  %d'%(name,os.getpid(),j))
        j += 10
        if j>300:
            break


if __name__ == '__main__':
    print("*"*8+' 主程序开始 '+"*"*8)
    p1 = Process(target = task_01,name="任务1",args=("A",0.5))  #  给task_01传递参数
    p2 = Process(target = task_02,name="任务2",args=("B",1))
    count = 0
    p1.start()   # 开启子程序
    p2.start()
    print('p1.name: ',p1.name)
    print('p2.name: ',p2.name)


    ## 通过主程序控制子程序
    count = 0
    while True:
        time.sleep(0.3)
        count += 5
        print('count: ', count)
        if count== 50:
            p1.terminate()
            p2.terminate()
            break
    print("#" * 8 + ' 主程序结束 ' + "#" * 8)
‘’‘
******** 主程序开始 ********
p1.name:  任务1
p2.name:  任务2
******** task_01 ********
******** task_02 ********
count:  5
count:  10
 A:  task_01.id: 3603, i:  0
count:  15
 A:  task_01.id: 3603, i:  1
 B:  task_02.id: 3604, j:  0
count:  20
count:  25
 A:  task_01.id: 3603, i:  2
count:  30
count:  35
 B:  task_02.id: 3604, j:  10
 A:  task_01.id: 3603, i:  3
count:  40
 A:  task_01.id: 3603, i:  4
count:  45
count:  50
######## 主程序结束 ########

Process finished with exit code 0
‘’‘

1.4 权重

进程之间不共享权重


import os
import time
from  multiprocessing import Process
N = 1
def task_01(name,s):
    print("*"*8+' task_01 '+"*"*8)
    global N
    while True:
        time.sleep(s)
        print(' %s:  task_01.id: %d, N:  %d'%(name,os.getpid(),N))
        N += 1
        if N>20:
            break

def task_02(name,s):
    print("*"*8+' task_02 '+"*"*8)
    global N
    while True:
        time.sleep(s)
        print(' %s:  task_02.id: %d, N:  %d'%(name,os.getpid(),N))
        N += 100
        if N>1000:
            break


if __name__ == '__main__':
    print("*"*8+' 主程序开始 '+"*"*8)
    p1 = Process(target = task_01,name="任务1",args=("A",0.5))  #  给task_01传递参数
    p2 = Process(target = task_02,name="任务2",args=("B",1))
    N = 100
    p1.start()   # 开启子程序
    p2.start()
    print('p1.name: ',p1.name)
    print('p2.name: ',p2.name)



    print("#" * 8 + ' 主程序结束 ' + "#" * 8)
‘’‘    
******** 主程序开始 ********
p1.name:  任务1
p2.name:  任务2
######## 主程序结束 ########
******** task_02 ********
******** task_01 ********
 A:  task_01.id: 3710, N:  1
 B:  task_02.id: 3711, N:  1
 A:  task_01.id: 3710, N:  2
 A:  task_01.id: 3710, N:  3
 B:  task_02.id: 3711, N:  101
 A:  task_01.id: 3710, N:  4
 A:  task_01.id: 3710, N:  5
 B:  task_02.id: 3711, N:  201
 A:  task_01.id: 3710, N:  6
 A:  task_01.id: 3710, N:  7
 B:  task_02.id: 3711, N:  301
 A:  task_01.id: 3710, N:  8
 A:  task_01.id: 3710, N:  9
 B:  task_02.id: 3711, N:  401
 A:  task_01.id: 3710, N:  10
 A:  task_01.id: 3710, N:  11
 B:  task_02.id: 3711, N:  501
 A:  task_01.id: 3710, N:  12
 A:  task_01.id: 3710, N:  13
 B:  task_02.id: 3711, N:  601
 A:  task_01.id: 3710, N:  14
 A:  task_01.id: 3710, N:  15
 B:  task_02.id: 3711, N:  701
 A:  task_01.id: 3710, N:  16
 A:  task_01.id: 3710, N:  17
 B:  task_02.id: 3711, N:  801
 A:  task_01.id: 3710, N:  18
 A:  task_01.id: 3710, N:  19
 B:  task_02.id: 3711, N:  901
 A:  task_01.id: 3710, N:  20

Process finished with exit code 0
‘’‘

1.5 全局变量list

进程之间不共享全局变量list

# 
import os
import time
import random
from  multiprocessing import Process
N = []
def task_01(name,s):
    print("*"*8+' task_01 '+"*"*8)
    global N
    while True:
        time.sleep(s)
        print(' {}:  task_01.id: {}, N1:  {}'.format(name,os.getpid(),N))
        N.append(-round(random.random(),1))
        if len(N)>9:
            break

def task_02(name,s):
    print("*"*8+' task_02 '+"*"*8)
    global N
    while True:
        time.sleep(s)
        print(' {}:  task_02.id: {}, N2:  {}'.format(name,os.getpid(),N))
        N.append(round(random.random())*100)
        if len(N)>8:
            break


if __name__ == '__main__':
    print("*"*8+' 主程序开始 '+"*"*8)
    p1 = Process(target = task_01,name="任务1",args=("A",0.5))  #  给task_01传递参数
    p2 = Process(target = task_02,name="任务2",args=("B",1))
    N = 100
    p1.start()   # 开启子程序
    p2.start()
    print('p1.name: ',p1.name)
    print('p2.name: ',p2.name)



    print("#" * 8 + ' 主程序结束 ' + "#" * 8)
    time.sleep(10)
    print('NNNNNN: ', N)
‘’‘
******** 主程序开始 ********
p1.name:  任务1
p2.name:  任务2
######## 主程序结束 ########
******** task_01 **************** task_02 ********

 A:  task_01.id: 3819, N1:  []
 B:  task_02.id: 3820, N2:  []
 A:  task_01.id: 3819, N1:  [-0.8]
 A:  task_01.id: 3819, N1:  [-0.8, -0.7]
 A:  task_01.id: 3819, N1:  [-0.8, -0.7, -0.8] 
 B:  task_02.id: 3820, N2:  [0]

 A:  task_01.id: 3819, N1:  [-0.8, -0.7, -0.8, -0.3]
 B:  task_02.id: 3820, N2:  [0, 0]
 A:  task_01.id: 3819, N1:  [-0.8, -0.7, -0.8, -0.3, -0.3]
 A:  task_01.id: 3819, N1:  [-0.8, -0.7, -0.8, -0.3, -0.3, -0.5]
 B:  task_02.id: 3820, N2:  [0, 0, 100]
 A:  task_01.id: 3819, N1:  [-0.8, -0.7, -0.8, -0.3, -0.3, -0.5, -0.3]
 A:  task_01.id: 3819, N1:  [-0.8, -0.7, -0.8, -0.3, -0.3, -0.5, -0.3, -0.9]
 B:  task_02.id: 3820, N2:  [0, 0, 100, 100]
 A:  task_01.id: 3819, N1:  [-0.8, -0.7, -0.8, -0.3, -0.3, -0.5, -0.3, -0.9, -0.2]
 B:  task_02.id: 3820, N2:  [0, 0, 100, 100, 100]
 B:  task_02.id: 3820, N2:  [0, 0, 100, 100, 100, 100]
 B:  task_02.id: 3820, N2:  [0, 0, 100, 100, 100, 100, 0]
 B:  task_02.id: 3820, N2:  [0, 0, 100, 100, 100, 100, 0, 0]
NNNNNN:  100

Process finished with exit code 0
‘’‘
山居秋暝LS
关注
专栏目录
python多进程+协程_python中多进程+协程的使用
weixin_39880301的博客
12-15 641
前面讲了为什么Python里推荐用多进程而不是多线程，但是多进程也有其自己的限制：相比线程更加笨重、切换耗时更长，并且在python的多进程下，进程数量不推荐超过CPU核心数(一个进程只有一个GIL，所以一个进程只能跑满一个CPU)，因为一个进程占用一个CPU时能充分利用机器的性能，但是进程多了就会出现频繁的进程切换，反而得不偿失。不过特殊情况(特指IO密集型任务)下，多线程是比多进程好用的。举个...
多进程、多线程、协程、多进程+协程、多线程+协程的并发效率对比
panshao521_的博客
12-12 1918
一、何为进程、线程、协程？ 1.进程：运行起来的程序就是进程，是操作系统分配资源的最小单位。 2.线程：线程是进程的组成部分，一个进程可以拥有多个线程，一个线程必须有一个父进程。 3.协程：是线程的更小切分，又称为“微线程”，是一种用户态的轻量级线程。 4.三者关系：进程里有线程，线程里有协程 二、进程、线程、协程的区别 1.进程：多进程是利用多核CPU来完成任务，进程拥有独立的内存空间，所以进程间数据不共享，进程之间的通讯是由操作系统完成的，在切换时，CPU需要进行上下文切换，导致通讯效率比较低、开销比较
进程+线程+协程+php,进程、线程和协程三者之间的区别和联系
weixin_39705794的博客
03-27 457
一、进程、线程、协程1，进程进程，直观点说，保存在硬盘上的程序运行以后，会在内存空间里形成一个独立的内存体，这个内存体有自己独立的地址空间，有自己的堆，上级挂靠单位是操作系统。操作系统会以进程为单位，分配系统资源(CPU时间片、内存等资源)，进程是资源分配的最小单位。2，线程(thread)(内核级线程)线程，有时被称为轻量级进程(Lightweight Process，LWP)，是操作系统调度(...
进程线程协程
我的博客
07-21 576
协程是一种高效的并发编程模型，适用于I/O密集型任务和需要大量并发连接的场景。与进程和线程相比，协程更加轻量级，但它无法利用多核CPU的并行能力。在实际应用中，选择合适的并发模型需要根据具体的任务特点和系统资源进行权衡。当然，有时用更直白的语言和生活中的比喻来解释协程会更容易理解。
进程、线程、协程
热门推荐
Pinker_Q
08-28 1万+
进程、线程、协程 一、概念与区分 1、进程 进程是程序一次动态执行的过程，是程序运行的基本单位。 每个进程都有自己的独立内存空间，不同进程通过进程间通信来通信。 进程占据独立的内存，所以上下文进程间的切换开销（栈、寄存器、页表、文件句柄等）比较大，但相对比较稳定安全。协程切换和协程切换 2、线程 线程又叫做轻量级进程，是CPU调度的最小单位。 线程从属于进程，是程序的实际执行者。一个进程至少包含一个主线程，也可以有更多的子线程。 多个线程共享所属进程的资源，同时线程也拥有自己的专属资源。
Python多进程+多线程+协程同时应用
qq_40132294的博客
02-08 5363
"""10000个请求，开启2个进程，进程中开启3个线程，线程中开启5个协程来处理 """ import requests, time from multiprocessing import Queue, Process import threading import gevent def process_work(q, p_name): """ 创建3个线程 :param q: 队列 :param pname: 进程名 :return: """ .
Python概念之多线程+多进程+协程
舌尖上的蛋炒饭的博客
12-08 899
Python概念之多线程+多进程+协程 文案来自于 多进程 多线程 协程 只是将文案中的代码自己修改了一下，解决了自己对于文章中不懂的地方，谨做记录，平时工作中，除了appium处理多个手机的时候用过多进程，其实很少用到这方面的知识，所以做一个简单的梳理，概念性的记录 多进程 linux或者Mac操作系统 Unix/Linux操作系统提供了一个fork()系统调用，它非常特殊。普通的函数调用，调用一次，返回一次，但是fork()调用一次，返回两次，因为操作系统自动把当前进程（称为父进程）复制了一份（称为子进
python中多进程+协程的使用
sun_daming的博客
05-26 6050
首先强调背景：        1、GIL是什么？    GIL的全称是Global Interpreter Lock(全局解释器锁)，为了数据安全所做的决定。     GIL全局解释器锁：     同一进程下的多线程共享数据，共享意味着竞争，竞争带来无序，为了数据安全所以需要加锁进行数据保护，GIL本质是一把 互斥锁，使并发变为串行，保证同一时间只有一条线程访问解释器级别的数据，这样就保证了解释...
python中的进程线程和协程
ximu__l的博客
04-30 1674
介绍了进程、线程和协程，并通过实例对三种操作进行了展示，最后说明了适合三种并发操作方式的相应场景和任务。
Python 的进程、线程和协程
Looking的博客
03-27 213
线程是进程的一个实体,是CPU调度和分派的基本单位,它是比进程更小的能独立运行的基本单位.线程自己基本上不拥有系统资源,只拥有一点在运行中必不可少的资源(如程序计数器,一组寄存器和栈),但是它可与同属一个进程的其他的线程共享进程所拥有的全部资源。协程调度切换时，将寄存器上下文和栈保存到其他地方，在切回来的时候，恢复先前保存的寄存器上下文和栈，直接操作栈则基本没有内核切换的开销，可以不加锁的访问全局变量，所以上下文的切换非常快。因此，没有线程切换的开销，和多线程比，线程数量越多，协程的性能优势就越明显。
Python之进程+线程+协程（异步、selectors模块、阻塞、非阻塞IO）
12-21
在IT领域，特别是软件开发中，进程、线程和协程是并发编程中的核心概念，它们用于优化系统资源的利用，提高程序的执行效率。在Python中，这些概念的运用和实现方式对于理解和编写高效的多任务应用至关重要。 一、...
Python之进程+线程+协程（进程间通信、进程同步、进程池、回调函数）
01-20
本篇文章依然是进程、线程方面的内容，主要讲进程间的通信、进程队列、进程同步、进程池、进程同步和回调函数 进程间通信 进程就是两个独立的内存空间在运行，这两块空间之间的通信就是内存通信。但因为是独立的，...
ks8 本地化部署 F5-TTS
陈锐的技术笔记
11-13 469
此外，F5-TTS 还创新性地引入了推理时的 Sway Sampling 策略，这一策略可以在推理阶段优先处理早期的流步骤，从而提高生成语音与输入文本的对齐效果。在 LibriSpeech-PC 数据集上，该模型的字错误率（WER）达到了2.42，并且在推理时的实时因子(RTF)为0.15，显著优于之前的扩散模型 E2TTS，后者在处理速度和鲁棒性上存在短板。传统的 TTS 模型往往需要进行复杂的持续时间建模、音素对齐和专门的文本编码，这些都增加了合成过程的复杂性。继续TSS的启动，进入pod 输入命令。
数据分析——学习框架
不迁怒，不贰过。小知识，大智慧。
11-11 2249
本教程旨在为读者提供一个系统化的数据分析学习框架，涵盖从数据收集、清洗、分析到可视化和报告的各个环节。通过深入探讨每个环节的理论与实践，读者将能够掌握数据分析的基本技能，提升数据处理和分析的能力。无论您是数据分析的初学者，还是希望进一步提升技能的专业人士，本教程都将为您提供有价值的指导和实用的工具，助您在数据分析的旅程中取得成功。
自动化爬虫DrissionPage
m0_55297736的博客
11-09 909
自动化爬虫DrissionPage
外星人入侵
weixin_60243362的博客
11-12 1335
外星人入侵项目实践
什么是Python模块化编程
最新发布
大数据实战派
11-13 253
模块化编程是一种编程方法论，它将程序的功能划分为多个独立的模块，每个模块负责程序中的一部分功能。通过这种方式，程序的代码被分割成更小、更易管理的部分，每个模块都可以独立开发、调试和测试，模块之间通过接口进行交互。模块化编程是将一个复杂的程序拆分为多个独立、功能明确的小模块的编程方法。这不仅提高了代码的复用性和可维护性，还促进了团队协作开发，增强了程序的扩展性。在实际开发中，模块化编程让代码结构更加清晰，逻辑更加简洁，为程序的长久维护和扩展打下了坚实的基础。
推荐一款管道数据检索工具：Pipedata-Pro
11-09 410
是一款专为设计石油、天然气、水和蒸汽管道及管道系统的工程师开发的应用程序。该应用程序提供了设计管道系统所需的工程数据，拥有一个全面的管道类型、配件和材料。
使用python3实现多进程+多线程+协程的组合
02-06
好的，这是使用 Python3 实现多进程、多线程和协程的组合的方法： 1. 多进程：可以使用 Python 的 `multiprocessing` 库来实现多进程编程。例如： ```python from multiprocessing import Process def foo(n): ...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值