Python -- 多任务、进程、线程

已于 2023-12-20 16:54:41 修改
阅读量257 收藏
点赞数
分类专栏： python 进程 线程 文章标签： python 开发语言
于 2023-07-11 00:29:49 首次发布
本文链接：https://blog.csdn.net/L1416279170/article/details/131628473
版权
python 同时被 3 个专栏收录
2 篇文章 0 订阅
订阅专栏
进程
1 篇文章 0 订阅
订阅专栏
线程
1 篇文章 0 订阅
订阅专栏

文章目录


好久没写了，回归一下，不然被列为失踪人口了！！！👌

多任务的介绍

同一时间执行多个任务

多任务的执行方式

  1. 并发
    在一段时间内交替去执行任务。
  2. 并行
    对于多核cpu处理多任务，操作系统会给cpu的每个内核安排一个执行的软件，多个内核是真正的一起执行软件。

进程

在Python程序中，想要实现多任务可以使用进程来完成，进程是实现多任务的一种方式。

进程的概念

一个正在运行 的程序或软件就是一个进程，它是操作系统进行资源分配的基本单位，也就是说每启动一个进程，操作系统都会给其分配一定的运行资源（内存资源）保证进程的运行。

  • 注意：
  • 应该程序至少有一个进程，一个进程默认有一个线程，进程里面可以创建多个线程，线程是依附在进程里面的，没有进程就没有线程

进程的作用

单进程：
默认程序运行创建一个进程：
单进程.py --> 进程{主线程[执行代码]}
多进程：
在这里插入图片描述

进程的使用

多进程

# 调用包
import multiprocessing
import time

# 跳舞任务
def dance():
    for i in range(3):
        print('跳舞中……')
        time.sleep(2)

# 唱歌任务
def sing():
    for i in range(3):
        print('唱歌中……')
        time.sleep(1)

# 创建子进程
dance_processing = multiprocessing.Process(target=dance)
sing_processing = multiprocessing.Process(target=sing)

# 启动对应的任务
if __name__ == '__main__':
    dance_processing.start()
    sing_processing.start()

获取进程编号

# 调用包
import multiprocessing
import time
import os

# 跳舞任务
def dance():
    # 获取当前进程(子进程)的编号
    dance_os = os.getpid()
    print('跳舞进程：', dance_os, multiprocessing.current_process())

    # 获取当前进程的父进程编号
    dance_os_parent = os.getppid()
    print('跳舞的父进程id：', dance_os_parent)

    for i in range(3):
        print(f'跳{i+1}舞中……')
        time.sleep(2)

# 唱歌任务
def sing():
    # 获取当前进程(子进程)的编号
    sing_os = os.getpid()
    print('唱歌进程：', sing_os, multiprocessing.current_process())

    # 获取当前进程的父进程编号
    sing_os_parent = os.getppid()
    print('唱歌的父进程id：', sing_os_parent)

    for i in range(3):
        print(f'唱{i+1}歌中……')
        time.sleep(1)
        os.kill(sing_os, 9)

if __name__ == '__main__':
    # 获取主进程id
    main_os = os.getpid()
    print('主进程：', main_os, multiprocessing.current_process())

    # 创建子进程
    dance_processing = multiprocessing.Process(target=dance, name='dance')
    # print('跳舞进程：', dance_processing)
    sing_processing = multiprocessing.Process(target=sing, name='sing')
    # print('唱歌进程：', sing_processing)

    # 启动对应的任务
    dance_processing.start()
    sing_processing.start()

进程执行带有参数的任务

介绍

Process类执行任务并给任务传参有两种方式：

  • args 表示以元祖的方式给执行任务传参
  • kwargs 表示以字典方式给执行任务传参

args参数和kwargs的使用

import multiprocessing
import time

# 跳舞任务
def dance(count):
    for i in range(count):
        print('跳舞中……')
        time.sleep(2)

# 唱歌任务
def sing(count):
    for i in range(count):
        print('唱歌中……')
        time.sleep(1)


# 启动对应的任务
if __name__ == '__main__':
    # 创建子进程
    dance_processing = multiprocessing.Process(target=dance, args=(3,))
    sing_processing = multiprocessing.Process(target=sing, kwargs={'count': 2})

    dance_processing.start()
    sing_processing.start()

进程注意点

  1. 进程之间不共享全局变量
  2. 主进程会等待所有的子进程结束再结束

进程之间不共享全局变量

import multiprocessing
import time

# 定义全局变量列表
g_list = []

# 添加数据的任务
def add_data():
    for i in range(3):
        # 不用加global(因为列表是可变类型，可以在原有内存的基础上修改数据，并且修改后内存地址不变)
        g_list.append(i)
        # 加上global 表示声明要修改全局变量的内存地址
        # g_list = [1, 2]
        print('append', i)
        time.sleep(0.2)
    print('添加完成：', g_list)

# 读取数据的任务
def read_data():
    print('read:', g_list)

if __name__ == '__main__':
    # 添加数据的子进程
    add_process = multiprocessing.Process(target=add_data)
    # 读取数据的子进程
    read_process = multiprocessing.Process(target=read_data)

    # 启动进程
    add_process.start()
    # 当前进程执行完成再执行完再继续往下执行
    add_process.join()
    read_process.start()
  • 结论： 进程之间不共享变量
    在这里插入图片描述

主进程会等待所有子进程执行结束再结束

根据以上代码测试，相信你已经发现了在这里插入图片描述

线程

介绍

在Python中，想要实现多任务除了使用进程以外，还可以使用线程来完成，线程是实现多任务的另一种方式。

概念

线程是进程中执行代码的一个分支，每一个执行分支（线程）想要执行代码需要cpu进行调度，也就是说线程是cpu调度的基本单位，每个进程至少都有一个线程，而这个线程就是我们通常说的主线程。

线程的作用

多线程可以完成多任务
多线程：
在这里插入图片描述
在这里插入图片描述

程序启动默认会有一个主线程，程序员自己创建的线程可以称为子线程，多线程可以完成多任务

多线程的使用

# 导入线程模块
import threading
import time


def dance():
    # 获取当前线程
    dance_thread = threading.current_thread()
    print('跳舞:', dance_thread)

    for i in range(3):
        print('跳舞ing')
        time.sleep(2)

def sing():
    # 获取当前线程
    current_thread = threading.current_thread()
    print('唱歌:', current_thread)

    for i in range(3):
        print('唱歌ing')
        time.sleep(1)


if __name__ == '__main__':
    # 获取当前线程
    main_thread = threading.current_thread()
    print('主线程:', main_thread)

    # 创建子线程
    dance_thread = threading.Thread(target=dance, name='dance')
    sing_thread = threading.Thread(target=sing, name='sing')

    # 启动子程序执行对于的任务
    dance_thread.start()
    sing_thread.start()

结果：

主线程: <_MainThread(MainThread, started 11968)>
跳舞: <Thread(dance, started 10584)>
跳舞ing
唱歌: <Thread(sing, started 3440)>
唱歌ing
唱歌ing
跳舞ing
唱歌ing
跳舞ing

线程执行有参数的任务

Thread类执行任务并给任务传参数有两种

  • args 表示以元祖的方式给执行任务传参
  • kwargs 表示以字典方式给执行任务传参
# 导入线程模块
import threading
import time


def dance(count):
    # 获取当前线程
    dance_thread = threading.current_thread()
    print('跳舞:', dance_thread)

    for i in range(count):
        print('跳舞ing')
        time.sleep(2)

def sing(count):
    # 获取当前线程
    current_thread = threading.current_thread()
    print('唱歌:', current_thread)

    for i in range(count):
        print('唱歌ing')
        time.sleep(1)


if __name__ == '__main__':
    # 获取当前线程
    main_thread = threading.current_thread()
    print('主线程:', main_thread)

    # 创建子线程
    dance_thread = threading.Thread(target=dance, name='dance', args=(2,))
    sing_thread = threading.Thread(target=sing, name='sing', kwargs={'count': 3})

    # 启动子程序执行对于的任务
    dance_thread.start()
    sing_thread.start()

结果：

主线程: <_MainThread(MainThread, started 7412)>
跳舞: <Thread(dance, started 15816)>
跳舞ing
唱歌: <Thread(sing, started 18212)>
唱歌ing
唱歌ing
跳舞ing
唱歌ing

线程注意点

  1. 线程之间是无序的
  2. 主线程会等待所有的子线程结束再结束
  3. 线程之间共享全局变量
  4. 线程之间共享全局变量数据出现错误问题

线程之间执行是无序的

import threading
import time

def task():
    time.sleep(1)
    # 获取当前线程
    print(threading.current_thread())

if __name__ == '__main__':
    # 循环创建大量线程，测试线程之间执行是否无序
    for i in range(20):
        # 每循环一次创建一个子线程
        sub_thread = threading.Thread(target=task)
        # 启动子线程对应的任务
        sub_thread.start()

结果：

<Thread(Thread-4 (task), started 16424)><Thread(Thread-11 (task), started 16816)><Thread(Thread-5 (task), started 11396)>
<Thread(Thread-17 (task), started 14800)>
<Thread(Thread-13 (task), started 23500)><Thread(Thread-20 (task), started 28080)>
<Thread(Thread-9 (task), started 32000)>
<Thread(Thread-6 (task), started 15764)><Thread(Thread-19 (task), started 5112)>
<Thread(Thread-1 (task), started 33744)>
<Thread(Thread-2 (task), started 26248)>
<Thread(Thread-18 (task), started 19632)><Thread(Thread-15 (task), started 20116)>
<Thread(Thread-14 (task), started 24540)><Thread(Thread-10 (task), started 28732)>
<Thread(Thread-12 (task), started 10912)>
<Thread(Thread-16 (task), started 25176)><Thread(Thread-8 (task), started 14792)>





<Thread(Thread-7 (task), started 20020)>


<Thread(Thread-3 (task), started 28072)>

线程之间执行是无序的，具体那个线程执行是由cpu调度决定的

主线程会等待所有的子线程执行结束再

import threading
import time

def task():
    while True:
        print('任务执行中……')
        time.sleep(0.3)

if __name__ == '__main__':
    # 创建子进程
    task_thread = threading.Thread(target=task)
    # 启动子线程对应的任务
    task_thread.start()

    #  主进程延迟1s
    time.sleep(1)
    print('over')

结果：

任务执行中……
任务执行中……
任务执行中……
任务执行中……
over
任务执行中……
任务执行中……
任务执行中……
任务执行中……

......

线程之间共享全局变量

import threading

# 定义全局变量
g_list = []

# 添加数据的任务
def add_data():
    for i in range(1, 4):
        g_list.append(i)
        print('add:', i)
    print('添加完成')

# 创建读取的任务
def read_data():
    print('g_list:', g_list)


if __name__ == '__main__':
    add_thread = threading.Thread(target=add_data)
    read_thread = threading.Thread(target=read_data)

    add_thread.start()
    add_thread.join()
    read_thread.start()

结果：

add: 1
add: 2
add: 3
添加完成
g_list: [1, 2, 3]

线程之间共享变量数据出现错误问题

import threading

g_num = 0

def task1():
    for i in range(10000000):
        global g_num
        g_num += 1
    print('task1', g_num)

def task2():
    for i in range(10000000):
        global g_num
        g_num += 1
    print('task2', g_num)


if __name__ == '__main__':
    first_thread = threading.Thread(target=task1)
    second_thread = threading.Thread(target=task2)

    first_thread.start()
    second_thread.start()

总数输出可能比200w少

解决方法：
线程同步：保证同一时刻只能有一个线程去操作全局变量，同步就是协同步调，按预定的先后次序进行运行。
线程同步的方式：

  1. 线程等待（join）
  2. 互斥锁

互斥锁

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

注意：
互斥锁是多个线程一起去抢，抢到锁的线程先执行，没抢到的线程需要等待，等互斥锁使用完释放后，其他等待的线程再去抢这个锁。

互斥锁的使用

import threading

g_num = 0

# 创建互斥锁,Lock本质是一个函数，通过调用函数可以创建一个互斥锁
lock = threading.Lock()

def task1():
    # 上锁
    lock.acquire()
    for i in range(10000000):
        global g_num
        g_num += 1
    print('task1', g_num)
    # 释放锁
    lock.release()

def task2():
    # 上锁
    lock.acquire()
    for i in range(10000000):
        global g_num
        g_num += 1
    print('task2', g_num)
    # 释放锁
    lock.release()


if __name__ == '__main__':
    first_thread = threading.Thread(target=task1)
    second_thread = threading.Thread(target=task2)

    first_thread.start()
    second_thread.start()

结果

task1 10000000
task2 20000000

总结：线程等待和互斥锁都是把多任务改成单任务去执行，保证了数据的准确性，但是执行性能会下降

死锁

一直等待对方释放锁的情景就是死锁

进程和线程的对比

  1. 关系对比
  2. 区别对比
  3. 优缺点对比

关系对比

  1. 线程是依附在进程里面的，没有进程就没有线程
  2. 一个进程默认提供一条线程，进程可以创建多个线程

区别对比

  1. 进程之间不共享全局变量
  2. 线程之间共享全局变量，但是要注意资源竞争的问题，解决办法：互斥锁或者线程同步
  3. 创建进程的资源开销要比创建线程资源开销大
  4. 进程是操作系统资源分配的基本单位，线程是CPU调度的基本单位
  5. 线程不能够独立执行，必须依存在进程中
  6. 多进程开发比单进程/多线程开发稳定性要强

优缺点

  • 进程：
    • 优点：可以用多核
    • 缺点：资源开销大

用于计算密集型的相关操作使用多进程

  • 线程：
    • 优点：资源开销小
    • 缺点：不能使用多核

文件写入，文件的下载，I/O操作

'有爬虫需求的dd我哦'
+v Lyj_txd
溏心蛋*
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
Python-----线程、进程、协程
weixin_46200045的博客
05-05 221
线程 多任务：操作系统可以同时运行多个任务。 python 默认是单任务 线程： 被称为轻量级进程，是程序执行流的最小单元。一个标准的线程由线程ID，当前指令指针（PC），寄存器集合和堆栈组成。另外，线程是进程中的一个实体，是CPU调度和分派的基本单位，线程自己不拥有系统资源，只拥有一点儿在运行中必不可少的资源，但它可与同属一个进程的其他线程共享进程所拥有的全部资源 主线程：当⼀个程序启动时，就有⼀个进程被操作系统（OS）创建，与此同时⼀个线程也⽴刻运 ⾏，该线程通常叫做程序的主线程 主线程的重要性： 1）
python--进程、线程、协程
大发的博客
03-26 478
pyhon—-进程线程、与协程基础概述 什么是进程？ 进程，是计算机中的程序关于某数据集合上的一次运行活动，是系统进行资源分配和调度的基本单位，是操作系统结构的基础。前面的话我也没懂，用非官方的白话来解释就是——执行中的程序是进程，比如qq不是进程，但是当我们双击qq开始使用它的时候，它就变成了一个进程。我们写的python程序，只有当我们执行它的时候，它才是进程。我们正在执行的IE浏览...
Python进程和线程
Dylan__D的博客
08-25 155
多任务的概念、进程的概念、多进程完成多任务、获取进程编号、线程的概念、多线程完成多任务。
应用技巧：python编程四种多线程应用，你知道几种？
程序员小芽的博客
07-04 1587
本文介绍了Python中多线程的所有方式，包括使用threading模块、使用concurrent.futures模块、使用multiprocessing模块以及使用asyncio模块。不同的方式适用于不同的场景，可以根据需要选择最合适的方式。多线程编程可以提高程序的效率和执行速度，但需要注意线程安全和锁的使用。
【Python】多线程实现多任务节省工作时长，去卷其他的事
qq_41604569的博客
03-27 556
需要注意的是，多线程执行任务列表可能会导致一些线程安全问题，特别是如果多个线程尝试访问相同的共享资源。因此，您应该根据您的具体需求和应用程序的架构来选择最合适的解决方案。最后，我们打印一条消息，表示所有任务都已完成。函数，它包含一些代码，该代码将在每个线程中执行。有一个任务列表一共10项，用python多线程执行代码怎么写。，并循环遍历任务列表。在每次迭代中，我们创建一个新的线程。接下来，我们创建了一个空的线程列表。然后，我们创建了一个任务列表。方法启动线程，并将线程。，表示要执行的任务。
python多任务
qq_35224503的博客
08-24 559
python多任务
python进阶之多进程多线程
MSJ3917的博客
12-29 947
1)进程是操作系统进行资源分配的基本单位2)进程可以有一个或多个子进程3)最原始的父进程是操作系统提供的1)线程是CPU进行调度的基本单位2)线程可以有一个或多个子线程3)线程是进程主动创建出来的,创建第一个子线程的时候才会出现主线程1-多进程:计算机分配资源的最小单位2-多线程:CPU进行调度的最小单位3-线程不能独立存在,必须依存于进程中4-多进程中,多个子进程和主进程之间,不会共享全局变量5-多线程中,多个子线程和主线程之间,会共享全局变量。
Python-huey小型多线程任务队列
08-11
huey提供了一种简单的方法来在Python应用中引入多线程和多进程，使得复杂的任务可以被分解为可独立执行的小单元，从而提高系统的响应速度和并发能力。 huey的核心特性包括： 1. **任务调度**：huey支持定时任务...
python-multiprocess:Python多进程示例
04-12
下面我们将深入探讨Python多进程的使用方法、核心概念以及一些常见应用场景。 一、`multiprocessing`模块介绍 `multiprocessing`模块是Python标准库的一部分，它提供了类似`threading`模块的功能，但基于进程而不是...
Python-在不同线程不同输入下运行相同的进程
08-11
在Python编程中，多线程（Multithreading）是一种实现并发执行任务的技术，它允许程序同时处理多个任务或数据。当需要在不同的线程中，根据不同的输入运行相同的进程时，我们可以利用Python的`threading`模块来实现...
python爬虫之多线程、多进程爬虫
02-24
多线程对爬虫的效率提高是非凡的，当我们使用python的多线程有几点是需要我们知道的：1.Python的多线程并不如java的多线程，其差异在于当python解释器开始执行任务时，受制于GIL(全局解释所)，Python的线程被限制到...
Python并发：多线程与多进程
02-24
线程与多线程一个线程可以看成是一个有序的指令流（完成特定任务的指令），并且可以通过操作系统来调度这些指令流。线程通常位于进程程里面，由一个程序计数器、一个堆栈和一组寄存器以及一个标识符组成。这些线程
python编程技巧之python多任务并发，并行与线程介绍与使用(详细版！！！)
但行好事，莫问前程
06-05 1294
python多任务并发，并行与线程介绍与使用并行与并发介绍多任务的介绍多任务简单实现查看线程数量验证子线程的创建与执行 并行与并发介绍        •并发：两个或多个事件在同一时间间隔内发生，这些事件在宏观上是同时发生的，在微观上是交替发生的， 操作系统的并发性指系统中同时存在着多个运行的程序        •并行：两个或多个事件在同一时刻发生  &nbsp
python多任务(进程+线程+对比)
东隅的博客
03-12 1527
python多任务 使用多任务的作用在于充分利用CPU资源，提高程序执行的效率，通常有并发和并行两种形式 实现方式： 多进程 多线程 多进程 进程概念 进程(Process)是资源分配的最小单位，它是操作系统进行资源分配和调度运行的基本单位，通俗理解:一个正在运行的程序就是一个进程﹒例如:正在运行的QQ，微信等他们都是一个进程.（而没有运行的称为程序） 如图，CPU会为进程分配内存、磁盘、网络等等资源 注：一个运行起来的程序至少有一个进程，也可以有多个 多.
python线程实现多任务
weixin_53308294的博客
02-04 1217
u_t.start() # start()去调用run方法运行结果：小结：①类里面必须要实现run()方法②创建的对象调用start()方法。由start()方法来调用子类的run()方法。而不是直接调用run()方法③run()方法什么时候执行完意味着这个线程什么时候结束④如果除了run()方法，自定义类里面还有其他方法，这些方法需要在run()方法中自己去调用，线程是不会自己调用的import sys。
在Python中使用多线程（通俗版本）
zheshiyangyang的博客
03-03 1347
这显然不是我们想要的结果，那我们该怎么办呢？这就不得不搬出线程的“
python——线程总结
python全栈
09-29 875
ProcessPoolExecutor：进程池ThreadPoolExecutor：线程池t1 = ThreadPoolExecutor(max_workers=5)：创建一个线程池，线程池中最多支持同时执行多少个任务t1.submit(函数名称)：往线程池中提交执行的任务t1.shutdown()：等待线程池中所有的任务执行完毕之后，开始执行。
Python 中别再用 ‘+‘ 拼接字符串了！
最新发布
xyh2004的博客
06-30 1219
在 Python 中，字符串是不可变的数据类型，这意味着一旦字符串被创建，它就不能被修改。因此，当你尝试通过使用+来连接字符串时，实际上 Python 会创建新的字符串对象，并将旧字符串的内容复制到新字符串中，然后添加新内容。这个过程在处理大量数据或在循环中进行时，会导致性能问题。
Python程序设计董付国(第二版)第13章多线程与多进程编程.pptx
11-13
"Python程序设计董付国(第二版)第13章深入探讨了多线程与多进程编程的概念和应用，强调了在不同场景下如何利用这些技术提升程序性能和用户体验。" 在计算机科学中，多线程与多进程编程是优化计算效率和改善用户交互...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

溏心蛋*

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值