[Python知识库]Python 多线程多进程任务详解

1. 什么是多任务？

多任务是指在同一时间内执行多个任务，并且分为并发和并行。

并发：在一段时间内交替去执行多个任务，任务数量大于CPU的核心数

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

?一个正在运行的程序就是一个进程

多进程，可以理解为在同时下载多个任务 同时执行多个进程 能够充分利用CPU资源 提高效率

2. 进程的创建步骤

# 1.导入进程包
import multiprocessing

# 2.通过进程类创建进程对象
# 进程对象 = multiprocessing.Process(target=任务名)

# 3.启动进程执行任务
# 进程对象.start()

2.1? 获取进程编号

# 获取进程编号的两种方式
# 1.获取当前进程编号 os.getpid()
"""
    import os
    pid = os.getpid()
    print(pid)
"""
# 2.获取当前父进程编号 os.getppid()
"""def work():
        print("work父进程编号:", os.getppid())
"""

3. 线程的创建步骤（线程的创建步骤是和进程很像的）

# 1.导入线程模块
import threading

# 2.通过线程类创建线程对象
# 进程对象 = threading.Thread(target=任务名)

# 3.启动线程对象
# 进程对象.start()

3.1 获取当前线程的线程对象

? 注意：多线程之间的执行是无序的，是由CPU调动决定的

import threading
import time


def task():
    # 加入延迟 延迟1秒
    time.sleep(1)
    # curren_thread 获取当前线程的线程对象
    thread = threading.current_thread()
    print(thread)


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

4.多进程（多线程）执行带有参数的任务

args 以元组的方式给执行任务传参 args=(3,) 必须要有这个逗号

kwargs 以字典方式给执行任务传参 kwargs={"num":3}

以下我用实例来说明一下

4.1? 多进程执行带有参数的任务

# 1.导入进程包
import multiprocessing
import time


# 唱歌
def sing(num, name):
    # for+自定义的迭代遍历名+in+列表名:
    # num是形参
    for i in range(num):
        print(name)
        print("唱歌..")
        # 延迟0.5秒
        time.sleep(0.5)

# 跳舞
def dance(num, name):
    for i in range(num):
        print(name)
        print("跳舞...")
        # 延迟0.5秒
        time.sleep(0.5)

if __name__ == '__main__':
    # 2.通过进程类创建进程对象
    # 进程对象 = multiprocessing.Process(target=任务名)
    # target: 指定进程执行的函数名
    # ars: 使用元组方式给指定任务传参     参数按照顺序传递
    # kwargs: 使用字典方式给指定任务传参   参数按照键的传递 键和参数名要一致
    sing_process = multiprocessing.Process(target=sing, args=(3, "xiaoming"))
    dance_process = multiprocessing.Process(target=dance, kwargs={"num": 2, "name": "xiaoming"})

    # 3.启动进程执行任务
    # 进程对象.start()
    sing_process.start()
    dance_process.start()
    # 多任务 并列多进程完成多任务

4.2? 多线程执行带有参数的任务

上面的条件是不变的 只是将其中

多进程的multiprocessing.Proces 变成了 多线程的threading.Thread

if __name__ == '__main__':
    # sing()
    # dance()
    # 2.通过线程类创建线程对象 args   元组方式传参要和参数的顺序一致
    sing_thread = threading.Thread(target=sing, args=(3, "xiaoming"))
    # 这里kwargs字典的键要和参数名称相同
    dance_thread = threading.Thread(target=dance, kwargs={"count": 2})

    # 3.启动线程对象
    sing_thread.start()
    dance_thread.start()
    # 主进程会等待所有子进程结束后再结束

5. 设置守护主进程（主线程）

主进程和主线程都是会等待所有子进程（子线索）结束以后 ，才会结束的 。

如果想要主进程（主线程）结束后， 子进程（子线索）不再执行，就需要设置守护。

5.1? 设置守护主进程的格式：

# 子对象.daemon = True

如下实例：

# 主进程会等待所有子进程结束后再结束
import time
import multiprocessing


def work():
    # 子进程工作2秒
    for i in range(10):
        print("工作中")
        time.sleep(0.2)


if __name__ == '__main__':
    # 创建子进程
    work_process = multiprocessing.Process(target=work)
    # 设置守护主进程 一旦主进程退出 子进程也会退出 不再执行子进程代码
    # 子对象.daemon = True
    work_process.daemon = True

    work_process.start()
    # 主进程睡眠1秒
    time.sleep(1)
    print("主进程执行完成....")

5.2? 设置守护主线程的格式有两种：

# 子对象.setDaemon(True) 或

# 子对象 = threading.Thread(target=work， demon=True)

import time
import threading

如下实例

def work():
    for i in range(10):
        print("工作..")
        time.sleep(0.2)


if __name__ == '__main__':
    # 设置守护主线程  主线程就不会再等待所有子进程结束后再结束
    # sub_thread = threading.Thread(target=work， demon=True)
    sub_thread = threading.Thread(target=work)
    # 子对象.setDaemon(True)
    sub_thread.setDaemon(True)
    sub_thread.start()

    # 主线程等待1秒后结束
    time.sleep(1)
    print("主线程结束了...")

6. 进程和线程对比

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

区别对比
1.创建进程的资源开销要比创建线程的资源开销要大
2.进程是操作系统资源分配的基本单位，线程是CPU调度的基本单位
3.线程不能够独立执行，必须依存在进程中

优缺点对比：
进程优缺点 可以用多核 资源开销大
线程优缺点 不可以使用多核 资源开销

有什么地方不清楚请赐教? 感谢*.*