进程和线程

已于 2024-05-18 11:37:58 修改
阅读量901 收藏 14
点赞数 12
分类专栏： Python 文章标签： python 开发语言
于 2024-05-09 20:20:26 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/m0_69004584/article/details/138591256
版权

目录

1、进程

1.1、单进程

1.2、多进程

1.3获取进程编号

1.4进程执行带有参数的任务

1.5进程的注意点（重点：进程间不共享全局变量）

1.6守护主进程

进程总结：

2、线程

2.1、多线程的基本使用

2.2、多线程执行带有参数的任务

2.3、线程的注意点：

2.3.1、线程之间执行是无序的

 2.3.2、主线程会等待所有的子线程执行结束在结束

 2.3.3、线程之间共享全局变量

2.3.4、线程间共享全局变量问题

线程等待（join）：

互斥锁

1、进程

1.1、单进程
import time
def dance():
    for i in range(5):
        time.sleep(1)
        print("跳舞", i)
​
def sing():
    for i in range(5):
        time.sleep(1)
        print("唱歌", i)
​
if __name__ == '__main__':
    dance()
    sing()

执行结果

跳舞 0
跳舞 1
跳舞 2
跳舞 3
跳舞 4
唱歌 0
唱歌 1
唱歌 2
唱歌 3
唱歌 4

单进程，需要10秒完成

最少有一个进程 这个进程中最少有一个线程

1.2、多进程

进程：在《运行》程序就是进程，进程是分配资源的最小单位

线程：使用资源的最小单位

Process进程类的说明：

Process（）

参数：

  • group：指定进程组，目前只能使用None

  • target：执行的目标任务名

  • name：进程名字
  • args：以元组的方式给执行任务传参

  • kwargs：以字典的方式给执行任务传参

Process创建的实例对象的常用方法：

  • start()：启动子进程实例

  • join()：等待子进程执行结束

  • terminate()：不管任务是否完成，立即终止子进程

Process创建的实例对象的常用属性：

name：当前进程的别名，默认为Process-N，N为从1开始递增的整数

多进程完成多任务的代码：

多进程的使用流程：

（1）导入模块（multiprocesing）

（2）创建子进程(Process)

（3）开启子进程(start)

import time
import multiprocessing
def dance():
    for i in range(5):
        time.sleep(1)
        print("跳舞", i)
​
def sing():
    for i in range(5):
        time.sleep(1)
        print("唱歌", i)
​
if __name__ == '__main__':
    # 创建子进程
    # Procrss:
    # target: 指定执行的任务名（函数名）
    myDance = multiprocessing.Process(target=dance)
    mySing = multiprocessing.Process(target=sing)
    # 开启子进程（如果不开启是不会执行子进程的）
    myDance.start()
    mySing.start()

多进程 需要5秒完成（提升执行的效率）

注意点！！！

有三个进程：1个主进程，2个子进程

有三个线程：每个进程里有一个线程（执行任务的）

一旦程序开启，默认就会有一个主进程，主进程里默认就会有一个主线程

1.3获取进程编号

获取进程编号的目的：验证主进程和子进程的关系，可以得知子进程是由哪个主进程创建出来的（因为子进程需要主进程回收资源）

获取进程编号的两种操作：

  • 获取当前进程编号 os.getpid()

  • 获取当前父进程编号 os.getppid()

获取当前进程编号：os.getpid()

单进程

import os
def dance():
    print("dance: ", os.getpid())
​
def sing():
    print("sing: ", os.getpid())
​
if __name__ == '__main__':
    print("主进程id: ", os.getpid())
    dance()
    sing()
运行结果
主进程id:  51264
dance:  51264
sing:  51264
    
    
id都相同，得出只有一个进程

多进程

import multiprocessing
import os
def dance():
    print("dance子进程id: ", os.getpid())
    print("dance父进程id: ", os.getppid())
​
def sing():
    print("sing子进程id: ", os.getpid())
    print("sing父进程id: ", os.getppid())
​
if __name__ == '__main__':
    print("主进程id: ", os.getpid())
    myDance = multiprocessing.Process(target=dance)
    mySing = multiprocessing.Process(target=sing)
    myDance.start()
    mySing.start()
​

运行结果

主进程id:  72076
dance子进程id:  21188
dance父进程id:  72076
sing子进程id:  43240
sing父进程id:  72076
1.4进程执行带有参数的任务
import os
import multiprocessing
# 带有参数的函数
def dance(count):
    for i in range(count):
        print("跳舞", i)
​
def sing(sum):
    print(sum)
​
if __name__ == '__main__':
    # args: 元组！！！  （单个元素的元组要有 逗号）
    # kwargs: 字典！！！（key值要和函数中的形参完全重名）
    myDance = multiprocessing.Process(target=dance, args=(5,))
    mySing = multiprocessing.Process(target=sing, kwargs={"sum": 5})
    myDance.start()
    mySing.start()

运行结果

跳舞 0
跳舞 1
跳舞 2
跳舞 3
跳舞 4
5
1.5进程的注意点（重点：进程间不共享全局变量）

进程间不共享全局变量

进程是分配资源的最小单位=====》每个进程(主进程，子进程)都会有自己独立的空间。

创建子进程会对主进程资源进行拷贝，也就是说子进程是主进程的一个副本。

之所以进程之间不共享全局变量，是因为操作的不是同一个进程里面的全局变量，只不过不同进程里面的全局变量名字相同而已。

import multiprocessing
import time
# 全局变量列表
globalNum = []
def myWrite():
    # 声明变量
    global globalNum
    # 向全局变量列表中写入数据
    for i in range(5):
        globalNum.append(i)
    print("myWrite方法中的globalNum:", globalNum)
​
​
def myRead():
    # 读取全局变量globalNum的值
    global globalNum
    print("myRead方法中的globalNum:", globalNum)
​
if __name__ == '__main__':
    mywrite = multiprocessing.Process(target=myWrite)
    myread = multiprocessing.Process(target=myRead)
    mywrite.start()
    time.sleep(1)   # 保证数据写入全局变量globalNum中
    myread.start()

运行结果

myWrite方法中的globalNum:[0, 1, 2, 3, 4]
myRead方法中的globalNum:[]
1.6守护主进程

注意！！！默认主进程会等待所有的子进程结束之后在结束

import multiprocessing
import time
def func():
    for i in range(5):
        time.sleep(0.2)
        print("func", i)
​
if __name__ == '__main__':
    # 程序一旦运行,就会默认创建主进程
    myFunc = multiprocessing.Process(target=func)   # 主进程创建了子进程
    myFunc.start()  # 主进程开启了子进程
    print("主进程over")

运行结果

主进程over
func 0
func 1
func 2
func 3
func 4

  • 为了保证子进程能够正常的运行，主进程会等待所有的子进程执行完以后在销毁，设置守护主进程的目的是主进程退出子进程销毁，不让主进程在等待子进程去执行

  • 设置守护主进程方式：子进程对象.daemon = True

  • 销毁子进程方式：子进程对象.terminate()

方式1：设置守护进程

import multiprocessing
import time
def func():
    for i in range(5):
        time.sleep(0.2)
        print("func", i)
​
if __name__ == '__main__':
    # 程序一旦运行,就会默认创建主进程
    myFunc = multiprocessing.Process(target=func)   # 主进程创建了子进程
    
    # 方式1：设置守护进程（注意：需要在start之前设置  否则无效）
    myFunc.daemon = True
    myFunc.start()  # 主进程开启了子进程
    time.sleep(1)
    print("主进程over")

方式2：手动设置

import multiprocessing
import time
def func():
    for i in range(5):
        time.sleep(0.2)
        print("func", i)
​
if __name__ == '__main__':
    # 程序一旦运行,就会默认创建主进程
    myFunc = multiprocessing.Process(target=func)   # 主进程创建了子进程
    myFunc.start()  # 主进程开启了子进程
    time.sleep(1)
    
    # 方式2：手动设置
    myFunc.terminate()
    print("主进程over")

运行结果

func 0
func 1
func 2
主进程over
进程总结：

1、多进程的使用流程：

（1）导入模块（multiprocesing）

（2）创建子进程(Process)

（3）开启子进程(start)

2、获取进程编号的两种操作：

  • 获取当前进程编号 os.getpid()

  • 获取当前父进程编号 os.getppid()

3、进程执行带有参数的任务

注意点：

args: 元组！！！ （单个元素的元组要有 逗号）

kwargs: 字典！！！（key值要和函数中的形参完全重名）

myDance = multiprocessing.Process(target=dance, args=(5,))
mySing = multiprocessing.Process(target=sing, kwargs={"sum": 5})

4、进程间不共享全局变量

5、守护主进程

主进程默认会等待所有的子进程结束之后在结束

让子进程随着主进程的结束而结束：（两种方法）

  • 守护进程（在start之前设置）

    myFunc.daemon = True

  • 手动设置

    myFunc.terminate()

2、线程

2.1、多线程的基本使用
import threading
import time


def dance():
    for i in range(5):
        print("跳舞",i)
        time.sleep(1)

def sing():
    for i in range(5):
        print("唱歌", i)
        time.sleep(2)

if __name__ == '__main__':
    myDance = threading.Thread(target=dance)
    mySing = threading.Thread(target=sing)
    myDance.start()
    mySing.start()
2.2、多线程执行带有参数的任务
import threading
import time


def dance(count):
    for i in range(count):
        print("跳舞",i)
        time.sleep(1)

def sing(count):
    for i in range(count):
        print("唱歌", i)
        time.sleep(2)

if __name__ == '__main__':
    myDance = threading.Thread(target=dance, args=(5,))
    # kwargs：字典的key值必须和函数的形参完全重名才可以
    mySing = threading.Thread(target=sing, kwargs={"count":5})
    myDance.start()
    mySing.start()

运行后默认会创建一个进程，该进程中默认有一个主线程，主线程执行代码，再创建两个子线程

即（一个进程，一个主线程，两个子线程）

2.3、线程的注意点：
  1. 线程之间执行是无序的
  2. 主线程会等待所有的子线程执行结束在结束
  3. 线程之间共享全局变量
  4. 线程之间共享全局变量数据出现错误问题
2.3.1、线程之间执行是无序的
# 线程之间是无序执行的

import threading
import time


def Func():
    time.sleep(1)
    print(threading.current_thread())

if __name__ == '__main__':
    for i in range(5):
        myFunc = threading.Thread(target=Func)
        myFunc.start()

运行结果

<Thread(Thread-1 (Func), started 33340)>
<Thread(Thread-4 (Func), started 57196)>

<Thread(Thread-3 (Func), started 74692)>

<Thread(Thread-2 (Func), started 63812)>
<Thread(Thread-5 (Func), started 68708)>

 2.3.2、主线程会等待所有的子线程执行结束在结束

解决方法：守护主线程

# 守护线程

import threading
import time


def Func():
    for i in range(5):
        time.sleep(0.2)
        print("func")

if __name__ == '__main__':
    # 让子进程随着主进程的结束而结束
    # 守护线程
    #（1）Thread(daemon = True)
    myFunc = threading.Thread(target=Func, daemon=True)
    myFunc.start()
    time.sleep(0.5)
    print("主线程over")

运行结果

func
func
主线程over

 2.3.3、线程之间共享全局变量
# 线程之间共享全局变量
import threading
import time

globalNum = []

def myWrite():
    global globalNum
    for i in range(5):
        globalNum.append(i)
    print(globalNum)

def myRead():
    global globalNum
    print(globalNum)

if __name__ == '__main__':
    mywrite = threading.Thread(target=myWrite)
    myread = threading.Thread(target=myRead)
    mywrite.start()
    time.sleep(1)
    myread.start()

运行结果

[0, 1, 2, 3, 4]
[0, 1, 2, 3, 4]

结论：

由于线程是依附于进程的，一个进程中的所有的线程都是使用同一片内存空间

一个进程中的，线程是共享全局变量的

2.3.4、线程间共享全局变量问题
import threading

globalNum = 0

def sumNum1():
    global globalNum
    for i in range(10000000):
        globalNum += 1
    print("方法sunNum1计算的结果：", globalNum)

def sumNum2():
    global globalNum
    for i in range(10000000):
        globalNum += 1
    print("方法sunNum1计算的结果：", globalNum)

if __name__ == '__main__':
    sumnum1 = threading.Thread(target=sumNum1)
    sumnum2 = threading.Thread(target=sumNum2)
    sumnum1.start()
    sumnum2.start()

运行结果

方法sunNum1计算的结果： 19120946
方法sunNum1计算的结果： 20000000

其结果值不相等，线程间共享全局变量出现问题

解决线程间共享全局变量问题

  • 方法1：线程等待（join）
  • 方法2：互斥锁
线程等待（join）：
import threading

globalNum = 0

def sumNum1():
    global globalNum
    for i in range(10000000):
        globalNum += 1
    print("方法sunNum1计算的结果：", globalNum)

def sumNum2():
    global globalNum
    for i in range(10000000):
        globalNum += 1
    print("方法sunNum1计算的结果：", globalNum)

if __name__ == '__main__':
    firstThread = threading.Thread(target=sumNum1)
    secondThread = threading.Thread(target=sumNum2)
    firstThread.start()
    # 主线程等待第一个线程执行完成以后，代码在继续执行，让其第二个线程执行
    # 线程同步：一个任务执行完以后另一个任务才能执行，同一个时刻只有一个任务执行
    firstThread.join()  # 让主线程等待firstThread执行完毕 在继续向下运行
    secondThread.start()

运行结果：

方法sunNum1计算的结果： 10000000
方法sunNum1计算的结果： 20000000

互斥锁

互斥锁：对共享数据进行锁定，保证同一时刻只能有一个线程去操作。

threading模块中定义了Lock变量，这个变量本质上是一个函数，通过调用这个函数可以获取一把互斥锁。

互斥锁的使用步骤：

# 创建锁

mutex = threading.Lock()

# 上锁

mutex.acquire()

# 释放锁

mutex.release()

注意点：

  • acquire和release方法之间的代码同一时刻只能有一个线程去操作
  • 如果在调用acquire方法的时候，其他线程已经使用了这个互斥锁，那么此时acquire方法会堵塞，直到这个互斥锁释放后才能再次上锁。
import threading

globalNum = 0
# 创建锁
mutex = threading.Lock()
def sumNum1():
    global globalNum
    # 上锁
    mutex.acquire()
    for i in range(10000000):
        globalNum += 1
    # 释放锁（如果不解锁，就会产生死锁问题）
    mutex.release()
    print("方法sunNum1计算的结果：", globalNum)

def sumNum2():
    global globalNum
    # 上锁（同一把锁，必须先解锁才可以上锁）
    mutex.acquire()
    for i in range(10000000):
        globalNum += 1
    # 释放锁
    mutex.release()
    print("方法sunNum1计算的结果：", globalNum)

if __name__ == '__main__':
    firstThread = threading.Thread(target=sumNum1)
    secondThread = threading.Thread(target=sumNum2)
    firstThread.start()
    secondThread.start()

运行结果

方法sunNum1计算的结果： 10000000
方法sunNum1计算的结果： 20000000

死锁

import threading

# 创建锁
mutex = threading.Lock()
def sumNum1():
    num = 1
    # 上锁
    mutex.acquire()
    if num == 1:
        mutex.release()  # 解除死锁
        return
    # 释放锁
    mutex.release()

def sumNum2():
    # 上锁
    mutex.acquire()
    print("sumNum2")
    # 释放锁
    mutex.release()

if __name__ == '__main__':
    firstThread = threading.Thread(target=sumNum1)
    secondThread = threading.Thread(target=sumNum2)
    firstThread.start()
    secondThread.start()

C#上位机--进程和线程的区别
zuowusheng的博客
02-22 3222
进程和线程掌握好，程序流程烦恼少
进程和线程的区别(超详细)
热门推荐
ThinkWon的博客
10-03 44万+
进程和线程 进程 一个在内存中运行的应用程序。每个进程都有自己独立的一块内存空间，一个进程可以有多个线程，比如在Windows系统中，一个运行的xx.exe就是一个进程。 线程 进程中的一个执行任务（控制单元），负责当前进程中程序的执行。一个进程至少有一个线程，一个进程可以运行多个线程，多个线程可共享数据。 与进程不同的是同类的多个线程共享进程的堆和方法区资源，但每个线程有自己的程序计数器、虚拟...
进程和线程的区别
x5856856的博客
07-27 2422
（4）可终止的阻塞状态：该状态的运行机制类似于不可中断的阻塞状态，只不过处在该状态下的进程可以响应致命信号，它可以替代有效但可能无法终止的不可中断的阻塞状态，以及易于唤醒但安全性欠佳的可中断的阻塞状态。：指的是进程都有完整的生命周期，而且在进程的生命周期内，进程的状态是不断变化的，另外进程具有动态的地址空间（包括代码、数据和进程控制块等）。：指的是进程是一个相对完整的资源分配和调度的基本单位，各个进程的地址空间是相互独立的，只有采用某些特定的通信机制才能实现进程之间的通信。
JAVA进程和线程
程序猿追的博客
11-06 9416
进程就是正在运行的程序，它是系统资源调度的独立单位，并且一个进程可以执行多个任务，而线程就是程序执行的任务，它是程序使用CPU的基本单位，因此也可以说线程是依赖于进程的。像比如任务管理器里面的运行任务就是线程。
java的进程和线程_java进程和线程区别与不同
weixin_35586996的博客
02-20 2951
java进程和线程区别与不同。一、定义1.进程是具有一定独立功能的程序关于某个数据集合上的一次运行活动，是系统进行资源分配和调度的一个独立单位。2.线程是进程的一个实体，是CPU调度和分派的基本单位，他是比进程更小的能独立运行的基本单位，线程自己基本上不拥有系统资源，只拥有一点在运行中必不可少的资源(如程序计数器，一组寄存器和栈)，一个线程可以创建和撤销另一个线程；进程和线程的关系：(1)一个线程...
进程和线程合集以及实例
406156440的博客
10-12 4047
文章目录进程和线程0.1 粗略介绍:0.2 线程进程区别:一.进程1.1 fork创建单进程1.2 multiprocessing:Process 创建子进程1.2 multiprocessing:Pool 创建进程池1.3 进程间通信 公共队列二. 线程2.1 多线程的优点:二. 线程2.1 创建线程 threading.Thread 进程和线程 0.1 粗略介绍: 举例: 运行QQ, 需要有的进程 (1)等待对方消息 (2)等待用户输入 (3)验证身份 (4)更新好友状态 计算机上的并行现象: 对于
详解进程和线程的区别
格子衫双肩包的专栏
04-13 2354
深入浅出的介绍进程和线程
进程和线程详解
让技术没有门槛
02-19 3194
这篇文章来给大家介绍一下进程和线程，希望大家看完能够对进程和线程有个更深的理解
进程和线程的关系
qq_40340448的博客
08-19 2万+
**一、进程 1、进程的概念** 进程是操作系统实现并发执行的重要手段，也是操作系统为程序提供的重要运行环境抽象。 进程最根本的属性是动态性和并发性。以下是从不同角度对进程的解释： a、进程是程序的一次执行 b、进程是可以与其他计算并发执行的计算...
Linux中进程和线程的对比与区别
09-15
在Linux操作系统中，进程和线程是两种不同的执行单元，它们在系统中有着各自的特点和作用。理解这两者的差异对于优化程序性能、管理和调度系统资源至关重要。 首先，让我们来看看进程和线程的概念： **进程...
进程和线程之间的关系
07-05
### 进程和线程之间的关系 在计算机科学领域中，进程和线程是两个非常重要的概念，它们之间既有联系又有区别。对于初学者来说，理解进程与线程的关系至关重要，因为这有助于深入掌握操作系统的基本原理及应用。下面...
Python中进程和线程的区别详解
09-21
特别是在Python这样的高级编程语言中，正确理解和运用进程与线程对于提高程序的执行效率和稳定性至关重要。本文将深入探讨Python中进程与线程的区别，并结合具体实例来帮助读者更好地理解这两个概念。 #### 二、...
阿里开源 CosyVoice2：打造 TTS 文本转语音实战应用
蜗牛的博客
05-23 1729
阿里通义实验室推出的音频基座大模型 FunAudioLLM 包含 SenseVoice 和 CosyVoice 两大模型。CosyVoice 2.0 在多语言支持、超低延迟、高精度、强稳定性和自然体验方面均有显著提升。它支持中文、英文、日文、韩文及多种中文方言，并实现了跨语言和混合语言的语音克隆。CosyVoice 2.0 集成了离线和流式建模技术，首包合成延迟低至150毫秒，发音错误率减少了30%到50%，并在基准测试中达到了最低字符错误率。
Python 实现桶排序详解
最新发布
wamp0001的博客
05-27 229
时效率极高，但需权衡空间开销。适用于大规模数据、外部排序及特定场景（如浮点数排序）。实际应用中需结合数据特点调整分桶策略，以平衡时间与空间效率。O(n + k)，k为桶数量（若每个桶内用O(n²)排序，则为O(n + n²/k)），通过将数据分配到多个“桶”中，每个桶单独排序后再合并。O(n)（数据均匀分布，每个桶元素数量均衡）O(n + k)（需要额外存储桶和桶内数据）O(n²)（所有数据集中在一个桶内）- 数据范围未知或动态变化。- 外部排序（如大数据）是（若桶内排序稳定）高（合并需额外数组）
【大模型应用开发】Qwen2.5-VL-3B识别视频
fengye002fly的博客
05-25 1293
本文记录了作者在本地和云服务器上尝试运行Qwen2.5-VL视频识别模型的过程。从安装依赖包（qwen-vl-utils、modelscope、transformers、torchvision）开始，经历了多次环境配置错误和版本兼容问题。在本地遇到显存溢出问题后，转向云服务器尝试，但依然未能成功运行。过程中发现官方文档存在参数问题，尝试了多种解决方案（包括修改代码、使用量化模型、调整环境变量等）。虽然最终未实现视频识别功能，但成功完成了图片识别测试，积累了宝贵的环境配置经验。
为（FramePack）的视频生成添加首尾帧功能
Shion's bla bla blog
05-27 264
本文介绍了FramePack图生视频项目新增的尾帧控制功能。作者指出官方代码原本仅支持首帧，但通过用户提交的PR（#167）现已实现对尾帧的控制。虽然该修改尚未被官方合并，但用户只需手动替换demo_gradio.py文件即可使用新功能。测试显示界面仅增加了尾帧选项，功能运行正常。文末附有实际应用示例的B站演示视频链接，展示了首尾帧控制的具体效果。该功能为6GB显存笔记本本地运行图生视频项目提供了更多创作可能性。
Python web 开发 Flask HTTP 服务
qq_30049249的博客
05-16 940
Flask 是一个轻量级的 Web 应用框架，它基于 Python 编写，特别适合构建简单的 Web 应用和 RESTful API。Flask 的设计理念是提供尽可能少的约定和配置，从而让开发者能够灵活地构建自己的 Web 应用。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值