Python多任务编程

最新推荐文章于 2024-03-30 17:05:44 发布

ahao~

最新推荐文章于 2024-03-30 17:05:44 发布

阅读量658

点赞数 1

文章标签： python 开发语言

本文链接：https://blog.csdn.net/m0_60121089/article/details/127872850

版权

1.进程与多任务

1. 1 多任务的介绍

1.使用多任务能充分利用CPU资源，提高程序的执行效率，让程序具备处理多任务的能力。

2.多任务执行方式有两种：

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

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

1.2 进程的介绍

1.进程（Process）是资源分配的最小单位。

2.多进程是Python程序中实现多任务的一种方式，使用多进程可以大大提高程序的执行效率。

1.3 多进程完成多任务

1.导入进程包。

2.创建子进程并指定执行的任务。

3.启动进程执行任务。

# 导入进程模块
import multiprocessing
import time

# 敲代码
def coding():
    for i in range(3):
        print("coding...")
        time.sleep(0.2)

# 听音乐
def music():
    for i in range(3):
        print("music...")
        time.sleep(0.2)

if __name__ == '__main__':
    # coding()
    # music()
    # 通过进程类创建进程对象
    coding_process = multiprocessing.Process(target=coding)
    music_process = multiprocessing.Process(target=music)
    # 启动进程
    coding_process.start()
    music_process.start()

1.4 进程执行带有参数的任务

进程执行带有参数的任务有两种方式：

1.元组方式传参：元组方式传参一定要和参数的顺序保持一致。

2.字典方式传参：字典方式传参字典中的key一定要和参数名保持一致。

# 导入进程模块
import multiprocessing
import time

# 敲代码
def coding(num,name):
    for i in range(num):
        print(name)
        print("coding...")
        time.sleep(0.2)

# 听音乐
def music(count):
    for i in range(count):
        print("music...")
        time.sleep(0.2)

if __name__ == '__main__':
    # coding()
    # music()
    # 通过进程类创建进程对象
    coding_process = multiprocessing.Process(target=coding,args=(3,"zs"))
    music_process = multiprocessing.Process(target=music,kwargs={"count":2})
    # 启动进程
    coding_process.start()
    music_process.start()

1.5 获取进程编号

1.获取当前进程编号

os.getpid()

2.获取当前父进程编号

os.getppid()

# 导入进程模块
import multiprocessing
import os
import time

# 敲代码
def coding():
    # 获取coding_process的编号
    print("coding_process>>>%d" % os.getpid())
    # 获取coding_process的父进程的编号
    print("coding_process的父进程>>>%d" % os.getppid())
    for i in range(3):
        print("coding...")
        time.sleep(0.2)

# 听音乐
def music():
    # 获取music_process的编号
    print("music_process>>>%d" % os.getpid())
    # 获取music_process的父进程的编号
    print("music_process的父进程>>>%d" % os.getppid())
    for i in range(3):
        print("music...")
        time.sleep(0.2)

if __name__ == '__main__':
    # 获取主进程的编号
    print("主进程>>>%d" % os.getpid())
    # 通过进程类创建进程对象
    coding_process = multiprocessing.Process(target=coding)
    music_process = multiprocessing.Process(target=music)
    # 启动进程
    coding_process.start()
    music_process.start()

两个子进程的父进程的编号与主进程的编号相同，证明两个子进程是由该父进程创建并启动的。

1.6 进程间不共享全局变量

创建子进程会对主进程资源进行拷贝，也就是子进程就是主进程的一个副本。
进程间不共享全局变量，因为操作的不是同一个进程里面的全局变量，只不过不同进程里面的全局变量名字相同而已。

import multiprocessing
import time

# 全局变量
my_list = []

# 写入数据
def write_data():
    for i in range(3):
        my_list.append(i)
        print("add:",i)
    print("write_data:",my_list)

# 读取数据
def read_data():
    print("read_data:",my_list)

if __name__ == '__main__':
    # 创建写入数据进程
    write_process = multiprocessing.Process(target=write_data)
    # 创建读取数据进程
    read_process = multiprocessing.Process(target=read_data)

    # 启动进程，执行任务
    write_process.start()
    time.sleep(1)
    read_process.start()

写入数据进程和读取数据进程不共享my_list这个全局变量。

1.7 主进程和子进程的结束顺序

默认情况下，为了保证子进程能够正常的运行，主进程会等待所有的子进程执行完后再结束。

如果想要让主进程结束后子进程就销毁，可以采取以下两种方式：

设置守护主进程方式：子进程对象.daemon = True
销毁子进程方式：子进程对象.terminate()

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.daemon = True

    # 启动子进程
    work_process.start()

    # 延时1秒
    time.sleep(1)

    # 方式二：手动销毁子进程
    work_process.terminate()

    print("主进程执行完毕")

2. 线程与多任务

2.1 线程的介绍

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

2.线程是程序执行的最小单位。

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

2.2 多线程完成多任务

1.导入线程模块

2.创建子线程

3.启动线程执行任务

import time
import threading

# 敲代码
def coding():
    for i in range(3):
        print("coding...")
        time.sleep(0.2)

# 听音乐
def music():
    for i in range(3):
        print("music...")
        time.sleep(0.2)

if __name__ == '__main__':
    # 创建子线程
    coding_thread = threading.Thread(target=coding)
    music_thread = threading.Thread(target=music)
    # 启动线程执行任务
    coding_thread.start()
    music_thread.start()

2.3 线程执行带有参数的任务

线程执行带有参数的任务有两种方式：

1.元组方式传参：元组方式传参一定要和参数的顺序保持一致。

2.字典方式传参：字典方式传参字典中的key一定要和参数名保持一致。

import time
import threading

# 敲代码
def coding(num):
    for i in range(num):
        print("coding...")
        time.sleep(0.2)

# 听音乐
def music(count):
    for i in range(count):
        print("music...")
        time.sleep(0.2)

if __name__ == '__main__':
    # 创建子线程
    coding_thread = threading.Thread(target=coding,args=(3,))
    music_thread = threading.Thread(target=music,kwargs={"count" : 2})
    # 启动线程执行任务
    coding_thread.start()
    music_thread.start()

2.4 主线程和子线程的结束顺序

默认情况下，为了保证子线程够正常的运行，主线程会等待所有的子线程执行完后再结束。

如果想要让主线程结束后子线程就销毁，可以采取以下两种方式：

方式一：参数方式设置守护主线程
方式二：方法方式设置守护主线程

import time
import threading

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

if __name__ == '__main__':
    # 创建线程
    # 方式一：参数方式设置守护主线程
    # work_thread = threading.Thread(target=work,daemon=True)
    work_thread = threading.Thread(target=work)

    # 方式二：方法方式设置守护主线程
    work_thread.setDaemon(True)

    # 启动线程执行任务
    work_thread.start()

    # 延时1秒
    time.sleep(1)
    print("主线程执行完毕")

2.5 线程间的执行顺序

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

import threading
import time

# 获取线程信息函数
def get_info():
    time.sleep(0.5)
    # 获取线程信息
    current_thread = threading.current_thread()
    print(current_thread)

if __name__ == '__main__':
    for i in range(10):
        # 创建子线程
        sub_thread = threading.Thread(target=get_info)
        # 启动线程执行任务
        sub_thread.start()

2.6 线程间共享全局变量

import threading
import time

# 全局变量
my_list = []

# 写入数据
def write_data():
    for i in range(3):
        my_list.append(i)
        print("add:",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()

线程间共享my_list这个共享变量。

2.7 线程间资源竞争问题

多线程同时操作全局变量可能会导致数据出现错误，可以使用线程同步方式来解决这个问题。

线程同步方式：

互斥锁

import threading

# 全局变量
g_num = 0

# 对g_num进行加操作
def sum_num1():
    for i in range(1000000):
        # 声明全局变量
        global g_num
        g_num += 1
    print("g_num1:",g_num)

# 对g_num进行加操作
def sum_num2():
    for i in range(1000000):
        # 声明全局变量
        global g_num
        g_num += 1
    print("g_num2:",g_num)

if __name__ == '__main__':
    # 创建子线程
    sum1_thread = threading.Thread(target=sum_num1)
    sum2_thread = threading.Thread(target=sum_num2)

    # 启动线程
    sum1_thread.start()
    sum2_thread.start()

2.8 互斥锁的使用

1.互斥锁的使用

threading.Lock()

2.上锁

mutex.acquire()

3.解锁

mutex.release()

import threading

# 全局变量
g_num = 0

# 对g_num进行加操作
def sum_num1():
    # 上锁
    mutex.acquire()

    for i in range(1000000):
        # 声明全局变量
        global g_num
        g_num += 1

    # 解锁
    mutex.release()

    print("g_num1:",g_num)



# 对g_num进行加操作
def sum_num2():
    # 上锁
    mutex.acquire()
    for i in range(1000000):
        # 声明全局变量
        global g_num
        g_num += 1

    # 解锁
    mutex.release()

    print("g_num2:",g_num)


if __name__ == '__main__':
    # 互斥锁的创建
    mutex = threading.Lock()

    # 创建子线程
    sum1_thread = threading.Thread(target=sum_num1)
    sum2_thread = threading.Thread(target=sum_num2)

    # 启动线程
    sum1_thread.start()
    sum2_thread.start()

2.9 死锁

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

死锁的结果：会造成应用程序停止响应，不能再处理其它任务了。

死锁的注意点：

使用互斥锁的时候需要注意死锁的问题，在合适的地方注意释放锁。
死锁一旦产生就会造成应用程序的停止响应，应用程序无法继续往下执行了。

import threading

# 全局变量
g_num = 0

# 对g_num进行加操作
def sum_num1():
    print("sum_num1...")

    # 上锁
    mutex.acquire()

    for i in range(1000000):
        # 声明全局变量
        global g_num
        g_num += 1

    print("g_num1:",g_num)


# 对g_num进行加操作
def sum_num2():
    print("sum_num2...")

    # 上锁
    mutex.acquire()
    for i in range(1000000):
        # 声明全局变量
        global g_num
        g_num += 1

    print("g_num2:",g_num)


if __name__ == '__main__':
    # 互斥锁的创建
    mutex = threading.Lock()

    # 创建子线程
    sum1_thread = threading.Thread(target=sum_num1)
    sum2_thread = threading.Thread(target=sum_num2)

    # 启动线程
    sum1_thread.start()
    sum2_thread.start()

线程sum1_thread占用锁资源，而线程sum2_thread请求锁资源，导致死锁，线程无法继续运行下去。

2.10 进程和线程的对比

2.10.1 关系对比

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

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

2.10.2 区别对比

进程之间不共享全局变量，而线程之间共享全局变量（但是要注意资源竞争的问题）。

创建进程的资源开销大于线程。

进程是OS资源分配的基本单位，线程是CPU调度的基本单位。

线程不能独立执行，必须依存在进程中。

2.10.3 优缺点

1.进程优缺点：

优点：可以用多核（多个进程并行执行）。

缺点：资源开销大。

2.线程优缺点：

优点：资源开销小。

缺点：只能使用单核（多个线程并发执行）。

ahao~

关注

1
点赞
踩
3

收藏

觉得还不错? 一键收藏
0
评论
Python多任务编程

1.进程（Process）是资源分配的最小单位。2.多进程是Python程序中实现多任务的一种方式，使用多进程可以大大提高程序的执行效率。1.多线程是Python程序中实现多任务的一种方式。2.线程是程序执行的最小单位。3.同属一个进程的多个线程共享进程所拥有的全部资源。
复制链接

扫一扫