Python进程和线程

最新推荐文章于 2023-10-06 09:43:16 发布
最新推荐文章于 2023-10-06 09:43:16 发布
阅读量147 收藏 2
点赞数
文章标签： python
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/dylan__d/article/details/132492390
版权

Python进程和线程

一、多任务的概念

1、什么是多任务？

多任务是指在同一时间内执行多个任务。

例如：现在电脑安装的操作系统都是多任务操作系统，可以同时运行着多个软件。

在这里插入图片描述

2、多任务的两种表现形式
  • 并发
  • 并行
3、并发操作

并发：在一段时间内交替去执行多个任务。

例如：对于单核cpu处理多任务,操作系统轮流让各个任务交替执行，假如:软件1执行0.01秒，切换到软件2，软件2执行0.01秒，再切换到软件3，执行0.01秒……这样反复执行下去
, 实际上每个软件都是交替执行的 . 但是，由于CPU的执行速度实在是太快了，表面上我们感觉就像这些软件都在同时执行一样 . 这里需要注意单核cpu是并发的执行多任务的。

在这里插入图片描述

4、并行操作

并行：在一段时间内真正的同时一起执行多个任务。

对于多核cpu处理多任务，操作系统会给cpu的每个内核安排一个执行的任务，多个内核是真正的一起同时执行多个任务。这里需要注意多核cpu是并行的执行多任务，始终有多个任务一起执行。

在这里插入图片描述

二、进程的概念

1、程序中实现多个任务的方式

在Python中，想要实现多任务可以使用多进程来完成。

2、进程的概念

进程（Process）是资源分配的最小单位，它是操作系统进行资源分配和调度运行的基本单位，通俗理解：一个正在运行的程序就是一个进程。

例如:正在运行的QQ，微信等它们都是一个进程。

在这里插入图片描述

注意：一个程序运行后至少右一个进程

3、多进程的作用
  • 未使用多进程

在这里插入图片描述

思考：图中是一个非常简单的程序，一旦运行这个程序，按照代码的执行顺序，func_A函数执行完毕后才会执行func_B这个函数，如果可以让func_A和func_B同时运行，显然执行这个程序的效率会大大提升。

在这里插入图片描述

  • 使用了多进程

在这里插入图片描述

三、多进程完成多任务

1、多进程完成多任务
# 导入进包
import multiprocessing
# 通过进程类创建进程对象
进程对象 = multiprocessing.Process()
# 启动进程执行任务
进程对象.start()
2、通过进程类创建进程对象
进程对象 = multiprocessing.Process([group [, target=任务名 [, name]]])

参数说明：

参数名说明
target执行的目标任务名，这里指的是函数名(方法名)
name进程名，一般不用设置
group进程组，目前只能使用None
3、进程创建与启动代码

边听音乐边敲代码：

import multiprocessing
import time


# 边听音乐边敲代码
def music():
    for i in range(5):
        print('听音乐。。。')
        time.sleep(0.3)


def coding():
    for i in range(5):
        print('敲代码。。。')
        time.sleep(0.3)


if __name__ == '__main__':
    music_process = multiprocessing.Process(target=music)
    coding_process = multiprocessing.Process(target=coding)
    
    music_process.start()
    coding_process.start()
4、进程执行带有参数的任务
Process([group [, target [, name [, args [, kwargs]]]]])

参数说明：

参数名说明
args以元组的方式给执行任务传参，args表示调用对象的位置参数元组，args=(1,2,‘anne’)
kwargs以字典方式给执行任务参数，kwargs表示调用对象的字典,kwargs={‘name’:‘anne’,‘age’:18}

案例：args参数和kwargs参数的使用

import multiprocessing
import time


# 边听音乐边敲代码
def music(num):
    for i in range(num):
        print('听音乐。。。')
        time.sleep(0.3)


def coding(num):
    for i in range(num):
        print('敲代码。。。')
        time.sleep(0.3)


if __name__ == '__main__':
    music_process = multiprocessing.Process(target=music, args=(10,))
    coding_process = multiprocessing.Process(target=coding, kwargs={'num': 10})

    music_process.start()
    coding_process.start()

案例：多个参数传递

import multiprocessing
import time


# 边听音乐边敲代码
def music(name, num):
    for i in range(num):
        print(f'{name}听音乐。。。')
        time.sleep(0.3)


def coding(name, num):
    for i in range(num):
        print(f'{name}敲代码。。。')
        time.sleep(0.3)


if __name__ == '__main__':
    music_process = multiprocessing.Process(target=music, args=('小明', 10))
    coding_process = multiprocessing.Process(target=coding, kwargs={'name': '小明', 'num': 10})

    music_process.start()
    coding_process.start()

四、获取进程编号

1、进程编号的作用

当程序中进程的数量越来越多时，如果没有办法区分主进程和子进程还有不同的子进程，那么就无法进行有效的进程管理，为了方便管理实际上每个进程都是有自己编程的。

2、两种进程编号
  • 获取当前进程编号
getpid()
  • 获取当前进程的父进程ppid = parent pid
getppid()
3、获取当前进程编号
import os


def func():
    # 获取当前进程编号
    print('当前进程编号：', os.getpid())
    # 获取父进程编号
    print('父进程编号', os.getppid())


func()

案例：获取子进程编号

import multiprocessing
import time
import os


# 边听音乐边敲代码
def music(name, num):
    for i in range(num):
        print('music-->子进程编号：', os.getpid())
        print(f'{name}听音乐。。。')
        time.sleep(0.3)


def coding(name, num):
    for i in range(num):
        print('coding-->子进程编号：', os.getpid())
        print(f'{name}敲代码。。。')
        time.sleep(0.3)


if __name__ == '__main__':
    music_process = multiprocessing.Process(target=music, args=('小明', 10))
    coding_process = multiprocessing.Process(target=coding, kwargs={'name': '小明', 'num': 10})

    music_process.start()
    coding_process.start()

案例：获取父进程编号

import multiprocessing
import time
import os


# 边听音乐边敲代码
def music(name, num):
    for i in range(num):
        print('music-->父进程编号：', os.getppid())
        print(f'{name}听音乐。。。')
        time.sleep(0.3)


def coding(name, num):
    for i in range(num):
        print('coding-->父进程编号：', os.getppid())
        print(f'{name}敲代码。。。')
        time.sleep(0.3)


if __name__ == '__main__':
    music_process = multiprocessing.Process(target=music, args=('小明', 10))
    coding_process = multiprocessing.Process(target=coding, kwargs={'name': '小明', 'num': 10})

    music_process.start()
    coding_process.start()

五、进程应用注意点

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

实际上创建一个子进程就是把主进程的资源进行拷贝产生了一个新的进程，这里的主进程和子进程是相互独立的。

案例：

import multiprocessing
import time

my_list = []


def write_data():
    for i in range(3):
        my_list.append(i)
    print(my_list)


def read_data():
    print('read_data-->', my_list)


if __name__ == '__main__':
    write_data_process = multiprocessing.Process(target=write_data)
    read_data_process = multiprocessing.Process(target=read_data)

    write_data_process.start()
    time.sleep(1)
    read_data_process.start()
'''
[0, 1, 2]
read_data--> []
'''

原理分析：

在这里插入图片描述

三个进程分别操作的都是自己进程里面的全局变量my_list, 不会对其它进程里面的全局变量产生影响，所以进程之间不共享全局变量，只不过进程之间的全局变量名字相同而已，但是操作的不是同一个进程里面的全局变量。

2、主进程与子进程的结束顺序

代码演示：

import multiprocessing
import time


def work():
    for i in range(10):
        print('正在敲代码...')
        time.sleep(0.2)


if __name__ == '__main__':
    work_process = multiprocessing.Process(target=work)

    work_process.start()
    time.sleep(1)
    print('主进程结束')

在这里插入图片描述

  • 解决方案一：设置守护进程
import multiprocessing
import time


def work():
    for i in range(10):
        print('正在敲代码...')
        time.sleep(0.2)


if __name__ == '__main__':
    # daemon=True设置守护进程
    work_process = multiprocessing.Process(target=work, daemon=True)

    work_process.start()
    time.sleep(1)
    print('主进程结束')
  • 解决方案二：销毁子进程
import multiprocessing
import time


def work():
    for i in range(10):
        print('正在敲代码...')
        time.sleep(0.2)


if __name__ == '__main__':
    work_process = multiprocessing.Process(target=work)

    work_process.start()
    time.sleep(1)
    # 让子进程直接销毁，表示终止执行， 主进程退出前，把所有子进程直接销毁就可以了
    work_process.terminate()
    print('主进程结束')

提示：以上两种方式都能保证主进程退出子进程销毁

六、线程的概念

1、线程的概念

在Python中想要实现多任务还可以使用多线程来完成

2、为什么使用多线程？

进程是分配资源的最小单位 , 一旦创建一个进程就会分配一定的资源 , 就像跟两个人聊QQ就需要打开两个QQ软件一样是比较浪费资源的 .

线程是程序执行的最小单位 , 实际上进程只负责分配资源 , 而利用这些资源执行程序的是线程 , 也就说进程是线程的容器 , 一个进程中最少有一个线程来负责执行程序 。同时线程自己不拥有系统资源，只需要一点儿在运行中必不可少的资源，但它可与同属一个进程的其它线程共享进程所拥有的全部资源。这就像通过一个QQ软件(一个进程)打开两个窗口(两个线程)跟两个人聊天一样 , 实现多任务的同时也节省了资源。

3、多线程的作用
def func_A():
    print('任务A')


def func_B():
    print('任务B')


func_A()
func_B()
  • 单线程执行

在这里插入图片描述

  • 多线程执行

在这里插入图片描述

八、多线程完成多任务

1、多线程完成多任务
# 导入线程模块
import threading
# 通过线程类创建线程对象
线程对象 = treading.Thread(target=任务名)
# 启动线程执行任务
线程对象.start()
参数名说明
target执行的目标任务后，这里指的是函数名(方法名)
name线程名，一般不用设置
group线程组，目前只能使用None
2、线程创建与启动

单线程案例：

import time


# 边听音乐边敲代码
def music():
    for i in range(5):
        print('听音乐。。。')
        time.sleep(0.3)


def coding():
    for i in range(5):
        print('敲代码。。。')
        time.sleep(0.3)


if __name__ == '__main__':
    music()
    coding()

多线程案例：

import time
import threading


# 边听音乐边敲代码
def music():
    for i in range(5):
        print('听音乐。。。')
        time.sleep(0.3)


def coding():
    for i in range(5):
        print('敲代码。。。')
        time.sleep(0.3)


if __name__ == '__main__':
    music_thread = threading.Thread(target=music)
    coding_thread = threading.Thread(target=coding)

    music_thread.start()
    coding_thread.start()
3、线程执行带有参数的任务
参数名说明
args以元组的方式给执行任务参数
kwargs以字典方式给执行任务传参
import time
import threading


# 边听音乐边敲代码
def music(num):
    for i in range(num):
        print('听音乐。。。')
        time.sleep(0.3)


def coding(num):
    for i in range(num):
        print('敲代码。。。')
        time.sleep(0.3)


if __name__ == '__main__':
    music_thread = threading.Thread(target=music, args=(5,))
    coding_thread = threading.Thread(target=coding, kwargs={'num': 5})

    music_thread.start()
    coding_thread.start()
4、主线程和子线程的结束顺序
import time
import threading


# 边听音乐边敲代码
def music():
    for i in range(5):
        print('听音乐。。。')
        time.sleep(0.4)


if __name__ == '__main__':
    music_thread = threading.Thread(target=music)

    music_thread.start()
    time.sleep(1)
    print('主进程结束')
  • 设置守护线程方式一：
import time
import threading


# 边听音乐边敲代码
def music():
    for i in range(5):
        print('听音乐。。。')
        time.sleep(0.4)


if __name__ == '__main__':
    music_thread = threading.Thread(target=music, daemon=True)

    music_thread.start()
    time.sleep(1)
    print('主进程结束')
  • 设置守护进程方式二：
import time
import threading


# 边听音乐边敲代码
def music():
    for i in range(5):
        print('听音乐。。。')
        time.sleep(0.4)


if __name__ == '__main__':
    music_thread = threading.Thread(target=music)
    music_thread.daemon = True

    music_thread.start()
    time.sleep(1)
    print('主进程结束')
5、线程间的执行顺序
for i in range(5):
    sub_thread = threading.Thread(target=task)
    sub_thread.start()

线程间的执行是无序的

验证：

  • 获取当前线程信息
# 通过current_thread方法获取线程对象
current_thread = threading.current_thread()
# 通过current_thread对象可以知道线程的相关信息，例如被创建的顺序
print(current_thread)
  • 线程间的执行顺序
import time
import threading


def get_info():
    time.sleep(0.5)
    current_thread = threading.current_thread()
    print(current_thread)


if __name__ == '__main__':
    for i in range(10):
        get_info_thread = threading.Thread(target=get_info)
        get_info_thread.start()

总结：线程间执行是无序的，是由CPU调度决定某个线程先执行的。

6、线程间共享全局变量
  • 线程间共享全局变量

多个线程都是在同一个进程中，多个线程使用的资源都是同一个进程中的资源，因此多线程间是共享全局变量

示例：

import time
import threading


my_list = []

def write_data():
    for i in range(5):
        my_list.append(i)
    print('write_data-->', my_list)

def read_data():
    print('read_data-->', my_list)


if __name__ == '__main__':
    write_thread = threading.Thread(target=write_data)
    read_thread = threading.Thread(target=read_data)

    write_thread.start()
    time.sleep(1)
    read_thread.start()
7、总结：进程和线程对比
  • 关系对比

1.线程是依附在进程里面的，没有进程就没有线程。

2.一个进程默认提供一条线程，进程可以创建多个线程。

  • 区别对比

1.进程之间不共享全局变量；线程之间共享全局变量

2.创建进程的资源开销要不创建线程的资源开销要大

3.进程是操作系统资源分配的基本单元，线程是CPU调度的基本单元

  • 优缺点对比

1.进程优缺点：

优点：可以使用多核

缺点：资源开销大

2.线程优缺点：

优点：资源开销小

一个进程中的资源，因此多线程间是共享全局变量

示例：

import time
import threading


my_list = []

def write_data():
    for i in range(5):
        my_list.append(i)
    print('write_data-->', my_list)

def read_data():
    print('read_data-->', my_list)


if __name__ == '__main__':
    write_thread = threading.Thread(target=write_data)
    read_thread = threading.Thread(target=read_data)

    write_thread.start()
    time.sleep(1)
    read_thread.start()
7、总结：进程和线程对比
  • 关系对比

1.线程是依附在进程里面的，没有进程就没有线程。

2.一个进程默认提供一条线程，进程可以创建多个线程。

  • 区别对比

1.进程之间不共享全局变量；线程之间共享全局变量

2.创建进程的资源开销要不创建线程的资源开销要大

3.进程是操作系统资源分配的基本单元，线程是CPU调度的基本单元

  • 优缺点对比

1.进程优缺点：

优点：可以使用多核

缺点：资源开销大

2.线程优缺点：

优点：资源开销小

缺点：不能使用多核

Dylan__D
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
python进程和线程用法知识点总结
09-19
在本篇文章里小编给大家整理了关于python进程和线程用法以及相关实例内容，需要的朋友们跟着学习下。
python中的进程与线程
HBT036017的博客
12-11 1431
python进程和线程
详解Python进程与线程
黑马程序员官方博客
01-13 2652
另外，线程是进程中的一个实体，是被系统独立调度和分派的基本单位，线程自己不拥有系统资源，只拥有一点儿在运行中必不可少的资源，但它可与同属一个进程的其它线程共享进程所拥有的全部资源。CPU的时间片轮转，在不同的时间段切换执行不同的进程，但是切换进程是比较耗时的；就引来了轻量级进程，也就是所谓的线程，一个进程中包括多个线程（代码流，其实也就是进程中同时跑的多个方法体）当一个程序启动时，就有一个进程被操作系统（OS）创建，与此同时一个线程也立刻运行，该线程通常叫做程序的主线程。
python-进程和线程
jjliu的博客
12-08 816
进程： 一个程序的执行实例就是一个进程，表现为程序是源代码编译后的文件，而这些文件存放在磁盘上。当程序被操作系统加载到内存中，就是进程。 进程中存放着指令和数据(资源)，它也是线程的容器。 进程( Process)是计算机中的程序关于某数据集合上的一次运行活动，是系统进行资源分配和调度的基本单位，是操作系统结构的基础。 Linux进程有父进程、子进程，Windows的进程是平等关系 线程： 线程是操作系统能够进行运算调度的最小单位。它被包含在进程之中，是进程中的实际运行单位。 线程，有时被称为轻量级进程
详解Python多线程、多进程
最新发布
Python栈
10-06 635
在学习Python的过程中，有接触到多线程编程相关的知识点，先前一直都没有彻底的搞明白。今天准备花一些时间，把里面的细节尽可能的梳理清楚。
Python -- 多任务、进程、线程
L1416279170的博客
07-11 239
同一时间执行多个任务args 表示以元祖的方式给执行任务传参kwargs 表示以字典方式给执行任务传参在Python中，想要实现多任务除了使用进程以外，还可以使用线程来完成，线程是实现多任务的另一种方式。
Python中进程和线程的区别详解
09-21
主要介绍了Python中进程和线程的区别详解,需要的朋友可以参考下
python进程和线程.pdf
05-13
第16章 进程和线程.pdf
python进程、线程面试复习要点【超级干货】.png
08-09
关于python的进程线程基础以及理论，总结了很多篇文章所得出的精华。应对面试绰绰有余，希望能帮助大家更好的理解python的线程与进程。在面试者如鱼得水！
python并发技术实现（多线程、多进程）
12-07
压缩包内包含四个文件，实现的效果都是通过多线程或多进程执行加法运算； multiprocess_queue，通过任务队列方式实现多进程任务；(multiprocessing模块） multithread_queue，通过任务队列方式实现多线程任务；（threading模块） multiprocess_pool，通过进程池方式实现多进程任务；（concurrent.futures模块） multithread_pool，通过线程池方式实现多线程任务； （concurrent.futures模块）
python进程与线程小结实例分析
01-20
传统方式是调用2个方法执行1个任务，方法按顺序依次执行 ...2个线程同时并发执行1个任务 # -*- coding:utf-8 -*- import threading import time def run(n): print('task',n) time.sleep(3) if
python如何控制进程或者线程的个数
12-16
日常开发中，难免遇到并发场景，而并发场景难免需要做流量控制，即需要对并发的进程或者线程的总量进行控制。 今天简单总结两种常用的控制线程个数的方法。 方法一：进程池/线程池 如下例demo所示， 创建了一个大小...
Python实战系列培训课程之进程和线程.pptx
04-09
进程： 对于操作系统来说，一个任务就是一个进程（Process），比如打开一个浏览器就是启动一个...在一个进程内部，要同时干多件事，就需要同时运行多个“子任务”，我们把进程内的这些“子任务”称为线程（Thread）。
python多进程和多线程究竟谁更快(详解)
09-21
下面小编就为大家带来一篇python多进程和多线程究竟谁更快(详解)。小编觉得挺不错的，现在就分享给大家，也给大家做个参考。一起跟随小编过来看看吧
一文掌握Python多线程与多进程
2201_75362610的博客
06-21 2317
并发是今天计算机编程中的一项重要能力，尤其是在面对需要大量计算或I/O操作的任务时。Python 提供了多种并发的处理方式，本篇文章将深入探讨其中的两种：多线程与多进程，解析其使用场景、优点、缺点，并结合代码例子深入解读。
Python 中的线程和进程精讲，建议收藏
pythonhy的博客
03-21 610
Python中的多进程是通过multiprocessing包来实现的，和多线程的threading.Thread差不多，它可以利用multiprocessing.Process对象来创建一个进程对象。这个进程对象的方法和线程对象的方法差不多也有start(), run(), join()等方法，其中有一个方法不同Thread线程对象中的守护线程方法是setDeamon，而Process进程对象的守护进程是通过设置daemon属性来完成的。
深入理解Python中的进程与线程
weixin_45841831的博客
05-04 1037
今天我们使用的计算机早已进入多CPU或多核时代，而我们使用的操作系统都是支持“多任务”的操作系统，这使得我们可以同时运行多个程序，也可以将一个程序分解为若干个相对独立的子任务，让多个子任务并发的执行，从而缩短程序的执行时间，同时也让用户获得更好的体验。因此在当下不管是用什么编程语言进行开发，实现让程序同时执行多个任务也就是常说的“并发编程”，应该是程序员必备技能之一。为此，我们需要先讨论两个概念，一个叫进程，一个叫线程。
Python入门教学——多进程和多线程
计算机硕士的博客
09-14 246
线程和进程、创建多个线程、锁、线程间通讯、创建多个进程、进程间通讯
python进程和线程的区别
06-03
Python进程和线程的区别在于： 1. 进程是操作系统中的一个执行单位，而线程是进程中的执行单位。一个进程可以包含多个线程。 2. 进程之间相互独立，每个进程都有自己独立的地址空间、数据栈、堆等资源，进程间通信...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值