python并发编程（理解多进程，多线程，多任务）

目录

• 一. 多任务开发、并发编程
• • 1. 多任务概述
  • 2. 同步和异步
• 二. 进程多任务
• • 1. 多进程基本语法：
• 三. 线程多任务
• • 1. 线程创建语法：

一. 多任务开发、并发编程

首先要了解，一个进程 (领导 - 数据调度) 中可以包含多个线程(职员 - 干活)。

1. 多任务概述

多个任务同时执行，说的就是并发操作，所以多任务开发也称为并发编程。

2. 同步和异步

多个任务执行过程中，会有执行顺序的概念，会出现不同的执行方式。

二. 进程多任务

进程：计算机中的一个独立执行的程序单元，一个软件可以包含多个进程。

1. 多进程基本语法：

(1) 传统调用方法 - 单任务执行

(2) 多进程调用 - 多任务

（3）进程的执行状态
进程在计算机中也不是一直都在运行的，底层是根据 CPU 时间片划分，当某个进程获取到 CPU 时间片 (单元时间) 时才会执行进程中的程序，进程就会出现如下的状态：

三. 线程多任务

进程：计算机中数据分配、资源调度的最小单元，一个程序可以包含多个进程，但是至少会有一个主进程。
一个 QQ 程序，可以包含多个进程 [视频、聊天、界面…]

线程：计算机中的最小执行单元，一个进程可以包含多个线程，但是至少会有一个主线程，由 CPU 调度完成具体的数据运算。

1. 线程创建语法：

1. 案例代码：（类型构建线程）

# 2、类型方式，构建多线程程序
class MyCounter(threading.Thread):
    """自定义线程类型，继承threading.Thread类"""
    # 类属性
    num = 1

    def run(self):
        """重写run方法，在线程start()启动后会自动执行"""
        while True:
            MyCounter.num += 1
            print(f"{threading.current_thread().getName()} num1: {MyCounter.num}")
            time.sleep(1)


# 创建线程对象
t1 = MyCounter()
t2 = MyCounter()
# 启动线程
t1.start()
t2.start()

① 给创建的线程命名
t.name = “新名称” # 直接操作属性
t.setName(“新名称”) # 通过 set 方法修改名称

② 获取当前正在执行的线程的名称
threading.current_thread().getName()

2. 案例代码：（资源独占）

"""
多线程 资源独占
    1、程序中有主线程、子线程，但是多个线程的执行过程，没有顺序。
        那个执行可以执行由CPU管理的！

    2、子线程没有执行结束时，主线程不会退出
        子线程没有执行结束时，主线程中的代码可以全部执行。
        一直到所有的子线程全部运行完毕，主线程才能退出[当前程序]

    3、线程资源独占：强制独占-当前时刻已经启动的线程占用所有资源
        其他线程排队，提升部分线程的优先级，将并发执行变成同步执行
"""
import time
import threading


def test(num):
    """计数器"""
    for i in range(num):
        print(f"{threading.current_thread().getName()}当前的循环次"
              f"数：{i+1}；存活线程:{threading.active_count()}")
        time.sleep(1)


if __name__ == "__main__":
    """程序启动的入口"""
    # 创建两个线程
    t1 = threading.Thread(target=test, args=(5,))
    t2 = threading.Thread(target=test, args=(3,))

    # 启动线程
    t1.start()
    t1.join() # ? 位置：t1占用所有资源，线程运行完毕后，其他线程才能执行。
    # t2.join() # 位置：t2线程没有启动，抢占资源就会报错！
    t2.start()
    # t1.join()   # ? 位置：t1线程t2线程，分配所有资源，等待t1线程和t2线程运行完成后，其他线程才能执行
    # t2.join()  # 如果已经由t1.join()在上一行编写了，这里就没有必要写t2.join()

    # 主线程中：会不会等待t1和t2执行完成后，再执行？
    for i in range(2):
        print(f"{threading.current_thread().getName()} i:{i}")
        time.sleep(1)
    print("main线程执行完成......")

3. 案例代码：（守护线程）

"""
守护线程：一个子线程，会随着主线程的退出直接退出
    不论子线程中是否执行完成
    不离不弃，死生相随
"""
import threading
import time


def test():
    while True:
        print(f"{threading.current_thread().getName()}线程"
              f"正在执行中....")
        time.sleep(1)
        print(threading.enumerate())
        print("~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~")


if __name__ == "__main__":
    # 创建一个子线程
    t = threading.Thread(target=test)
    t.name = "正在跟家兴聊天中"
    t.daemon = True
    # t.setDaemon(True)  # 设置t线程为主线程的守护线程
    t.start()

    time.sleep(2)
    print("主线程：QQ软件")
    # 这句话执行完成，表示主线程中没有代码了~