python使用multiprocessing库和threading库实现多进程与多线程

2021/8/22 7:06:23

本文主要是介绍python使用multiprocessing库和threading库实现多进程与多线程,对大家解决编程问题具有一定的参考价值,需要的程序猿们随着小编来一起学习吧!

目录
  • 一、多进程
    • 1. 进程的创建步骤
    • 2. 进程执行带有参数的任务
    • 3. 获取进程编号
    • 4. 进程的注意点
    • 5. 进程状态
    • 6. 案例-视频文件夹高并发copy器(多进程)
  • 二、多线程
    • 1. 线程的创建步骤
    • 2. 线程执行带有参数的任务
    • 3. 主线程与子线程的结束顺序
    • 4. 线程间的执行顺序
    • 5. 进程和线程对比
      • 关系对比
      • 区别对比
      • 优缺点对比
    • 6. 案例-视频文件夹高并发copy器(多线程)

一、多进程

1. 进程的创建步骤

  1. 导入进程包

import multiprocessing

  1. 通过进程类创建进程对象sub_process

sub_process = multiprocessing.Process(target=任务名)

参数名 说明
target 执行的目标任务名,这里指函数名(方法名)
name 进程名,一般不用设置
group 进程组,目前只能使用None
  1. 启动进程执行任务

sub_process.start()

"""
1. 导入进程包
import multiprocessing
2. 通过进程类创建进程对象
sub_process = multiprocessing.Process()
3. 启动进程执行任务
sub_process.start()
"""

import multiprocessing
import time


def sing():
    for i in range(3):
        print("sing")
        time.sleep(0.5)


def dance():
    for i in range(3):
        print("dance")
        time.sleep(0.5)


if __name__ == '__main__':
    # 创建子进程sing
    sing_process = multiprocessing.Process(target=sing)
    # 创建子进程dance
    dance_process = multiprocessing.Process(target=dance)
    # 启动进程
    sing_process.start()
    dance_process.start()

2. 进程执行带有参数的任务

参数名 说明
args 以元组的形式传参
kwargs 以字典的形式传参
if __name__ == '__main__':
    # args: 元组形式传参
    sing_process = multiprocessing.Process(target=sing, args=(3,))
    # kwargs: 字典形式传参
    dance_process = multiprocessing.Process(target=dance, kwargs={"num": 3})
    sing_process.start()
    dance_process.start()

3. 获取进程编号

  1. 获取当前进程编号 os.getpid()
  2. 获取当前父进程编号 os.getppid()
import os
pid = os.getpid()
print(pid)
import multiprocessing
import time
import os


def sing(num, name):
    print("sing - current process id", os.getpid())
    print("sing - parent's process id", os.getppid())
    for i in range(num):
        print(name)
        print("sing...")
        time.sleep(0.5)


def dance(num, name):
    print("dance - current process id", os.getpid())
    print("dance - the parent's process id", os.getppid())
    for i in range(num):
        print(name)
        print("dance...")
        time.sleep(0.5)


if __name__ == '__main__':
    sing_process = multiprocessing.Process(target=sing, args=(3, "mateo"))
    dance_process = multiprocessing.Process(target=dance, kwargs={"num": 3, "name": "ciro"})
    sing_process.start()
    dance_process.start()

4. 进程的注意点

  1. 主进程默认会等待所有的子进程执行结束再结束
  2. 设置守护主进程,主进程结束则子进程强制结束 sub_process.daemon = True

5. 进程状态

  1. 判断进程是否正在运行:p.is_alive()
  2. 等待进程结束:p.join()

6. 案例-视频文件夹高并发copy器(多进程)

import multiprocessing
import os
import time


def copy_file(filename, source_dir, destination_dir):
    # 1. 拼接源文件路径和目标文件路径
    source_path = source_dir + "/" + filename
    destination_path = destination_dir + "/" + filename
    # 2. 打开源文件和目标文件
    with open(source_path, "rb") as source_file:
        with open(destination_path, "wb") as destination_file:
            # 3. 循环读取源文件到目标路径
            while True:
                data = source_file.read(1024)
                if data:
                    destination_file.write(data)
                else:
                    break


if __name__ == '__main__':
    # 1. 定义源文件夹和目标文件夹
    source_dir = r"D:\python\cs61a\resources\tutorials video"
    destination_dir = "videos"
    # 2. 创建目标文件夹
    try:
        os.mkdir(destination_dir)
    except OSError:
        print("folder exists")

    # 3. 读取源文件夹的文件列表
    file_list = os.listdir(source_dir)

    # 开始时间
    start_time = time.perf_counter()
    # 4. 遍历文件列表实现拷贝
    sub_processes = []
    for filename in file_list:
        # copy_file(filename, source_dir, destination_dir)
        # 5. 使用多进程实现多任务拷贝
        sub_process = multiprocessing.Process(target=copy_file,
                                              args=(filename, source_dir, destination_dir))
        sub_process.start()
        sub_processes.append(sub_process)
    # 结束时间
    for sub_process in sub_processes:
        sub_process.join()
    end_time = time.perf_counter()
    print("并发使用时间:", end_time - start_time)

结果1: 并发使用时间: 1.0547636 s, 单线程使用时间: 1.2491160000000001 s

结果2: 并发使用时间: 0.8891155999999999 s, 单线程使用时间: 1.1450036 s

二、多线程

多线程是python程序中实现多任务的一种方式。

线程是程序执行的最小单位

同属一个进程的多个线程共享进程所拥有的全部资源

1. 线程的创建步骤

  1. 导入线程模块

import threading

  1. 通过线程类创建进程对象sub_process

sub_thread = threading.Thread(target=任务名)

参数名 说明
target 执行的目标任务名,这里指函数名(方法名)
name 线程名,一般不用设置
group 线程组,目前只能使用None
  1. 启动线程执行任务

sub_thread.start()

"""
1. 导入线程模块
import threading
2. 通过线程类创建进程对象sub_process
sub_thread = threading.Thread(target=任务名)
3. 启动线程并执行任务
sub_thread.start()
"""
import time
import threading


def sing():
    for i in range(3):
        print("sing...")
        time.sleep(1)


def dance():
    for i in range(3):
        print("dance...")
        time.sleep(1)


if __name__ == '__main__':

    sing_thread = threading.Thread(target=sing)
    dance_thread = threading.Thread(target=dance)

    sing_thread.start()
    dance_thread.start()

2. 线程执行带有参数的任务

参数名 说明
args 以元组的形式传参
kwargs 以字典的形式传参
if __name__ == '__main__':
    # args: 元组形式传参
    sing_thread = threading.Thread(target=sing, args=(3,))
    # kwargs: 字典形式传参
    dance_thread = threading.Thread(target=dance, kwargs={"num": 3})
    sing_thread.start()
    dance_thread.start()

3. 主线程与子线程的结束顺序

  1. 主线程默认会等待所有的子线程执行结束再结束

  2. 设置守护主线程,主线程结束则子线程强制结束

    # 设置守护主进程方式 1
    work_thread = threading.Thread(target=work, daemon=True)
    # 设置守护主进程方式 2
    # work_thread.setDaemon(True)
    

4. 线程间的执行顺序

  1. 线程间执行是无序的,由CPU调度决定
  2. 获取当前的线程信息 threading.current_thread()
import time
import threading


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


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

5. 进程和线程对比

关系对比

  1. 线程依附在进程中,没有进程就没有线程
  2. 一个进程默认提供一条线程,进程可以创建多个线程

区别对比

  1. 创建进程的资源开销比创建线程开销更大
  2. 进程是操作系统资源分配的基本单位,线程是CPU调度的基本单位
  3. 线程不能独立执行

优缺点对比

  1. 进程可以用多核,但资源开销大
  2. 线程资源开销小,但不能使用多核

6. 案例-视频文件夹高并发copy器(多线程)

import threading
import os
import time


def copy_file(filename, source_dir, destination_dir):
    # 1. 拼接源文件路径和目标文件路径
    source_path = source_dir + "/" + filename
    destination_path = destination_dir + "/" + filename
    # 2. 打开源文件和目标文件
    with open(source_path, "rb") as source_file:
        with open(destination_path, "wb") as destination_file:
            # 3. 循环读取源文件到目标路径
            while True:
                data = source_file.read(1024)
                if data:
                    destination_file.write(data)
                else:
                    break


if __name__ == '__main__':
    # 1. 定义源文件夹和目标文件夹
    source_dir = r"D:\python\cs61a\resources\tutorials video"
    destination_dir = "videos"
    # 2. 创建目标文件夹
    try:
        os.mkdir(destination_dir)
    except OSError:
        print("folder exists")

    # 3. 读取源文件夹的文件列表
    file_list = os.listdir(source_dir)

    # 开始时间
    start_time = time.perf_counter()
    # 4. 遍历文件列表实现拷贝
    sub_threads = []
    for filename in file_list:
        # copy_file(filename, source_dir, destination_dir)
        # 5. 使用多进程实现多任务拷贝
        sub_thread = threading.Thread(target=copy_file,
                                              args=(filename, source_dir, destination_dir))
        sub_thread.start()
        sub_threads.append(sub_thread)
    # 结束时间
    for sub_thread in sub_threads:
        sub_thread.join()
    end_time = time.perf_counter()
    print("并发使用时间:", end_time - start_time, "s")

结果1: 并发使用时间: 0.6955842 s

结果2: 并发使用时间: 0.5768514 s

主要参考:黑马程序员



这篇关于python使用multiprocessing库和threading库实现多进程与多线程的文章就介绍到这儿,希望我们推荐的文章对大家有所帮助,也希望大家多多支持为之网!


扫一扫关注最新编程教程