python多任务编程

liftword2天前技术文章5

Process进程类的说明

Process([group [, target [, name [, args [, kwargs]]]]])

  • group：指定进程组，目前只能使用None
  • target：执行的目标任务名
  • name：进程名字
  • args：以元组方式给执行任务传参
  • kwargs：以字典方式给执行任务传参

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

  • start()：启动子进程实例（创建子进程）
  • join()：等待子进程执行结束
  • terminate()：不管任务是否完成，立即终止子进程

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

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

import multiprocessing
import time
# 跳舞任务
def dance():
    for i in range(5):
        print("跳舞中...")
        time.sleep(0.2)
# 唱歌任务
def sing():
    for i in range(5):
        print("唱歌中...")
        time.sleep(0.2)
if __name__ == '__main__':
    # 创建跳舞的子进程
    # group: 表示进程组，目前只能使用None
    # target: 表示执行的目标任务名(函数名、方法名)
    # name: 进程名称, 默认是Process-1, .....
    dance_process = multiprocessing.Process(target=dance, name="myprocess1")
    sing_process = multiprocessing.Process(target=sing)
    # 启动子进程执行对应的任务
    dance_process.start()
    sing_process.start()
复制代码

多进程创建步骤

  1. 导入进程包
  2. import multiprocessing
  3. 创建子进程并指定执行的任务
  4. sub_process = multiprocessing.Process (target=任务名)
  5. 启动进程执行任务
  6. sub_process.start()

获取进程编号

# os.getpid() 表示获取当前进程编号
# os.getppid() 表示获取当前父进程编号
import multiprocessing
import time
import os


# 跳舞任务
def dance():
    # 获取当前进程的编号
    print("dance:", os.getpid())
    # 获取当前进程
    print("dance:", multiprocessing.current_process())
    # 获取父进程的编号
    print("dance的父进程编号:", os.getppid())
    for i in range(5):
        print("跳舞中...")
        time.sleep(0.2)
        # 扩展:根据进程编号杀死指定进程
        os.kill(os.getpid(), 9)


# 唱歌任务
def sing():
    # 获取当前进程的编号
    print("sing:", os.getpid())
    # 获取当前进程
    print("sing:", multiprocessing.current_process())
    # 获取父进程的编号
    print("sing的父进程编号:", os.getppid())
    for i in range(5):
        print("唱歌中...")
        time.sleep(0.2)


if __name__ == '__main__':

    # 获取当前进程的编号
    print("main:", os.getpid())
    # 获取当前进程
    print("main:", multiprocessing.current_process())
    # 创建跳舞的子进程
    # group: 表示进程组，目前只能使用None
    # target: 表示执行的目标任务名(函数名、方法名)
    # name: 进程名称, 默认是Process-1, .....
    dance_process = multiprocessing.Process(target=dance, name="myprocess1")
    sing_process = multiprocessing.Process(target=sing)

    # 启动子进程执行对应的任务
    dance_process.start()
    sing_process.start()
复制代码

执行带参数的任务

import multiprocessing
import time


# 带有参数的任务
def task(count):
    for i in range(count):
        print("任务执行中..")
        time.sleep(0.2)
    else:
        print("任务执行完成")


if __name__ == '__main__':
    # 创建子进程
    # args: 以元组的方式给任务传入参数
    # sub_process = multiprocessing.Process(target=task, args=(5,))
    # sub_process.start()
    # kwargs: 表示以字典方式传入参数
    sub_process = multiprocessing.Process(target=task, kwargs={"count": 3})
    sub_process.start()
复制代码

进程之间不共享变量

import multiprocessing
import time

# 定义全局变量
g_list = list()


# 添加数据的任务
def add_data():
    for i in range(5):
        g_list.append(i)
        print("add:", i)
        time.sleep(0.2)

    # 代码执行到此，说明数据添加完成
    print("add_data:", g_list)


def read_data():
    print("read_data", g_list)


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

    # 启动子进程执行对应的任务
    add_data_process.start()
    # 主进程等待添加数据的子进程执行完成以后程序再继续往下执行，读取数据
    add_data_process.join()
    read_data_process.start()

    print("main:", g_list)

    # 总结: 多进程之间不共享全局变量
    #输出
    add: 0
    add: 1
    add: 2
    add: 3
    add: 4
    add_data: [0, 1, 2, 3, 4]
    main: []
    read_data []
复制代码

线程类Thread的说明

Thread([group [, target [, name [, args [, kwargs]]]]])

  • group: 线程组，目前只能使用None
  • target: 执行的目标任务名
  • args: 以元组的方式给执行任务传参
  • kwargs: 以字典方式给执行任务传参
  • name: 线程名，一般不用设置
import threading
import time

# 唱歌任务
def sing():
    # 扩展： 获取当前线程
    # print("sing当前执行的线程为：", threading.current_thread())
    for i in range(3):
        print("正在唱歌...%d" % i)
        time.sleep(1)

# 跳舞任务
def dance():
    # 扩展： 获取当前线程
    # print("dance当前执行的线程为：", threading.current_thread())
    for i in range(3):
        print("正在跳舞...%d" % i)
        time.sleep(1)


if __name__ == '__main__':
    # 扩展： 获取当前线程
    # print("当前执行的线程为：", threading.current_thread())
    # 创建唱歌的线程
    # target： 线程执行的函数名
    sing_thread = threading.Thread(target=sing)

    # 创建跳舞的线程
    dance_thread = threading.Thread(target=dance)

    # 开启线程
    sing_thread.start()
    dance_thread.start()
复制代码
  1. 导入线程模块
  2. import threading
  3. 创建子线程并指定执行的任务
  4. sub_thread = threading.Thread(target=任务名)
  5. 启动线程执行任务
  6. sub_thread.start()

线程执行带任务的参数

import threading
import time


# 带有参数的任务
def task(count):
    for i in range(count):
        print("任务执行中..")
        time.sleep(0.2)
    else:
        print("任务执行完成")


if __name__ == '__main__':
    # 创建子线程
    # args: 以元组的方式给任务传入参数
    # sub_thread = threading.Thread(target=task, args=(5,))
    # sub_thread.start()
    sub_thread = threading.Thread(target=task, kwargs={"count": 3})
    sub_thread.start()
复制代码

互斥锁

# 创建锁
mutex = threading.Lock()

# 上锁
mutex.acquire()

...这里编写代码能保证同一时刻只能有一个线程去操作, 对共享数据进行锁定...

# 释放锁
mutex.release()
复制代码

互斥锁应用

import threading


# 定义全局变量
g_num = 0

# 创建全局互斥锁
lock = threading.Lock()


# 循环一次给全局变量加1
def sum_num1():
    # 上锁
    lock.acquire()
    for i in range(1000000):
        global g_num
        g_num += 1

    print("sum1:", g_num)
    # 释放锁
    lock.release()


# 循环一次给全局变量加1
def sum_num2():
    # 上锁
    lock.acquire()
    for i in range(1000000):
        global g_num
        g_num += 1
    print("sum2:", g_num)
    # 释放锁
    lock.release()


if __name__ == '__main__':
    # 创建两个线程
    first_thread = threading.Thread(target=sum_num1)
    second_thread = threading.Thread(target=sum_num2)
    # 启动线程
    first_thread.start()
    second_thread.start()

    # 提示：加上互斥锁，那个线程抢到这个锁我们决定不了，那线程抢到锁那个线程先执行，没有抢到的线程需要等待
    # 加上互斥锁多任务瞬间变成单任务，性能会下降，也就是说同一时刻只能有一个线程去执行

相关文章

Python 多任务编程

多任务的介绍利用现学知识能够让两个函数或者方法同时执行吗？不能，因为之前写的程序都是单任务的，也就是说一个函数或者方法执行完成另外一个函数或者方法才能执行，要想实现这种操作就需要使用多任务多任务的最大...

Python实现多进程的四种方式

方式一: os.fork()# -*- coding:utf-8 -*- """ pid=os.fork() 1.只用在Unix系统中有效，Windows系统中无效 2...

【Python程序开发系列】一文教你使用协程处理多任务(案例源码)

这是Python程序开发系列原创文章，我的第188篇原创文章。一、协程相关背景知识前文回顾：Python语言高级实战-基于协程的方式来实现异步并发编程（附源码和实现效果）【Python程序开发系列】进...

python多进程的分布式任务调度应用场景及示例

多进程的分布式任务调度可以应用于以下场景：分布式爬虫：import multiprocessing import requests def crawl(url): response = re...

Python中的多进程详解，让你的程序更快更强!

Python是一门高级编程语言，拥有简单易用、面向对象、可扩展等优点，因此被广泛应用于各种领域。但是在Python中，由于GIL（全局解释器锁）的存在，导致了多线程的效率不高。因此，在某些情况下，我们...

蜀ICP备2024111239号-1