Python核心编程总结(五多任务编程之进程与线程)

Posted 2022-01-11 生命是有光的

tags:

篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了Python核心编程总结(五多任务编程之进程与线程)相关的知识，希望对你有一定的参考价值。

✍、脑图时刻

五、多任务编程之进程与线程

✍、脑图时刻
1、多任务编程
1.1、多任务的概念
1.2、多任务的执行方式
1.3、进程
1.4、多进程的使用
1.4.1、获取进程编号
1、获取当前进程编号
2、获取当前父进程编号
3、小结

1.4.2、进程执行带有参数的任务
1、args参数的使用
2、kwargs参数的使用
3、小结

1.4.3、进程的注意点
1、进程之间不共享全局变量
2、进程之间不共享全局变量小结
3、主进程等待所有子进程执行结束

1.5、线程
1.6、多线程的使用
1.6.1、多线程完成多任务的代码
1.6.2、线程执行带有参数的任务
1、args参数的使用
2、kwargs参数的使用
3、小结

1.6.3、线程的注意点
1、线程之间执行是无序的
2、主线程会等待所有子线程执行结束再结束
3、线程之间共享全局变量
4、线程之间共享全局变量数据出现错误问题
5、小结

1.7、互斥锁
1.7.1、互斥锁的使用
1.7.2、操作
1.7.3、小结

1.8、死锁
1.8.1、避免死锁

1.9、进程和线程对比
1.9.1、关系对比
1.9.1、区别对比
1.9.3、优缺点对比
1.9.4、小结

1、多任务编程

我们之前所写的程序都是单任务的，也就是说一个函数或者方法执行完成另外一个函数或者方法才能执行，要想实现这种操作就需要使用多任务。多任务的最大好处是充分利用CPU资源，提高程序的执行效率。

1.1、多任务的概念

多任务是指在同一时间内执行多个任务。例如: 现在电脑安装的操作系统都是多任务操作系统，可以同时运行着多个软件。

1.2、多任务的执行方式

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

例如：对于单核cpu处理多任务,操作系统轮流让各个软件交替执行，假如:软件1执行0.01秒，切换到软件2，软件2执行0.01秒，再切换到软件3，执行0.01秒……这样反复执行下去。表面上看，每个软件都是交替执行的，但是，由于CPU的执行速度实在是太快了，我们感觉就像这些软件都在同时执行一样，这里需要注意单核cpu是并发的执行多任务的。
并行：对于多核cpu处理多任务，操作系统会给cpu的每个内核安排一个执行的软件，多个内核是真正的一起执行软件。这里需要注意多核cpu是并行的执行多任务，始终有多个软件一起执行。

1.3、进程

一个正在运行的程序或者软件就是一个进程，它是操作系统进行资源分配的基本单位，也就是说每启动一个进程，操作系统都会给其分配一定的运行资源(内存资源)保证进程的运行。

注意：

一个程序运行后至少有一个进程，一个进程默认有一个线程，
进程里面可以创建多个线程，线程是依附在进程里面的，没有进程就没有线程。

1.4、多进程的使用

导入进程包

# 导入进程包
import multiprocessing

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()

执行结果：

跳舞中...
唱歌中...
跳舞中...
唱歌中...
跳舞中...
唱歌中...
唱歌中...
跳舞中...
唱歌中...
跳舞中...

小结：

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

1.4.1、获取进程编号

获取进程编号的目的是验证主进程和子进程的关系，可以得知子进程是由那个主进程创建出来的

获取进程编号的两种操作：

获取当前进程编号
获取当前父进程编号

1、获取当前进程编号

os.getpid() 表示获取当前进程编号。

示例代码：

import multiprocessing
import time
import os


# 跳舞任务
def dance():
    # 获取当前进程的编号
    print("dance:", os.getpid())
    # 获取当前进程
    print("dance:", multiprocessing.current_process())
    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())
    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()

执行结果：

main: 17008
main: <_MainProcess(MainProcess, started)>
dance: 7732
dance: <Process(myprocess1, started)>
跳舞中...
sing: 16616
sing: <Process(Process-2, started)>
唱歌中...
唱歌中...
唱歌中...
唱歌中...
唱歌中...

2、获取当前父进程编号

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()

执行结果：

main: 3688
main: <_MainProcess(MainProcess, started)>
dance: 16700
dance: <Process(myprocess1, started)>
dance的父进程编号: 16992
跳舞中...
sing: 17076
sing: <Process(Process-2, started)>
sing的父进程编号: 13272
唱歌中...
唱歌中...
唱歌中...
唱歌中...
唱歌中...

3、小结

获取当前进程编号
- os.getpid()
获取当前父进程编号
- os.getppid()
获取进程编号可以查看父子进程的关系

1.4.2、进程执行带有参数的任务

前面我们使用进程执行的任务是没有参数的，假如我们使用进程执行的任务带有参数，如何给函数传参呢?

Process类执行任务并给任务传参数有两种方式:

args 表示以元组的方式给执行任务传参
kwargs 表示以字典方式给执行任务传参

1、args参数的使用

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()

执行结果：

任务执行中..
任务执行中..
任务执行中..
任务执行中..
任务执行中..
任务执行完成

2、kwargs参数的使用

import multiprocessing
import time


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


if __name__ == '__main__':
    # 创建子进程

    # kwargs: 表示以字典方式传入参数
    sub_process = multiprocessing.Process(target=task, kwargs="count": 3)
    sub_process.start()

执行结果：

任务执行中..
任务执行中..
任务执行中..
任务执行完成

3、小结

进程执行任务并传参有两种方式:

元组方式传参(args): 元组方式传参一定要和参数的顺序保持一致。
字典方式传参(kwargs): 字典方式传参字典中的key一定要和参数名保持一致。

1.4.3、进程的注意点

进程之间不共享全局变量
主进程会等待所有的子进程执行结束再结束

1、进程之间不共享全局变量

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 []

原因解释：

2、进程之间不共享全局变量小结

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

3、主进程等待所有子进程执行结束

假如我们现在创建一个子进程，这个子进程执行完大概需要2秒钟，现在让主进程执行0.5秒钟就退出程序，查看一下执行结果，示例代码如下:

import multiprocessing
import time


# 定义进程所需要执行的任务
def task():
    for i in range(10):
        print("任务执行中...")
        time.sleep(0.2)

if __name__ == '__main__':
    # 创建子进程
    sub_process = multiprocessing.Process(target=task)
    sub_process.start()

    # 主进程延时0.5秒钟
    time.sleep(0.5)
    print("over")
    exit()

    # 总结： 主进程会等待所有的子进程执行完成以后程序再退出

执行结果：

任务执行中...
任务执行中...
任务执行中...
over
任务执行中...
任务执行中...
任务执行中...
任务执行中...
任务执行中...
任务执行中...
任务执行中...

通过上面代码的执行结果，我们可以得知: 主进程会等待所有的子进程执行结束再结束

假如我们就让主进程执行0.5秒钟，子进程就销毁不再执行，那怎么办呢?

我们可以设置守护主进程或者在主进程退出之前让子进程销毁

守护主进程：

守护主进程就是主进程退出子进程销毁不再执行

子进程销毁：

子进程执行结束

保证主进程正常退出的示例代码:

import multiprocessing
import time


# 定义进程所需要执行的任务
def task():
    for i in range(10):
        print("任务执行中...")
        time.sleep(0.2)

if __name__ == '__main__':
    # 创建子进程
    sub_process = multiprocessing.Process(target=task)
    # 设置守护主进程，主进程退出子进程直接销毁，子进程的生命周期依赖与主进程
    # sub_process.daemon = True
    sub_process.start()

    time.sleep(0.5)
    print("over")
    # 让子进程销毁
    sub_process.terminate()
    exit()

    # 总结： 主进程会等待所有的子进程执行完成以后程序再退出
    # 如果想要主进程退出子进程销毁，可以设置守护主进程或者在主进程退出之前让子进程销毁

执行结果：

任务执行中...
任务执行中...
任务执行中...
over

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

1.5、线程

在Python中，想要实现多任务除了使用进程，还可以使用线程来完成，线程是实现多任务的另外一种方式。

线程是进程中执行代码的一个分支，每个执行分支（线程）要想工作执行代码需要cpu进行调度，也就是说线程是cpu调度的基本单位，每个进程至少都有一个线程，而这个线程就是我们通常说的主线程。

1.6、多线程的使用

导入线程模块

#导入线程模块
import threading

线程类Thread参数说明

Thread([group [, target [, name [, args [, kwargs]]]]])
- group: 线程组，目前只能使用None
- target: 执行的目标任务名
- args: 以元组的方式给执行任务传参
- kwargs: 以字典方式给执行任务传参
- name: 线程名，一般不用设置
启动线程：
- 启动线程使用 start 方法

1.6.1、多线程完成多任务的代码

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()

执行结果：

正在唱歌...0
正在跳舞...0
正在唱歌...1
正在跳舞...1
正在跳舞...2
正在唱歌...2

总结：

导入线程模块
- import threading
创建子线程并指定执行的任务
- sub_thread = threading.Thread(target=任务名)
启动线程执行任务
- sub_thread.start()

1.6.2、线程执行带有参数的任务

前面我们使用线程执行的任务是没有参数的，假如我们使用线程执行的任务带有参数，如何给函数传参呢?

Thread类执行任务并给任务传参数有两种方式:

args 表示以元组的方式给执行任务传参
kwargs 表示以字典方式给执行任务传参

1、args参数的使用

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()

执行结果：

任务执行中..
任务执行中..
任务执行中..
任务执行中..
任务执行中..
任务执行完成

2、kwargs参数的使用

import threading
import time


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


if __name__ == '__main__':
    # 创建子线程
    # kwargs: 表示以字典方式传入参数
    sub_thread = threading.Thread(target=task, kwargs="count": 3)
    sub_thread.start()

执行结果：

任务执行中..
任务执行中..
任务执行中..
任务执行完成

3、小结

线程执行任务并传参有两种方式：

元组方式传参(args) ：元组方式传参一定要和参数的顺序保持一致。
字典方式传参(kwargs)：字典方式传参字典中的key一定要和参数名保持一致。

1.6.3、线程的注意点

线程之间执行是无序的
主线程会等待所有的子线程执行结束再结束
线程之间共享全局变量
线程之间共享全局变量数据出现错误问题

1、线程之间执行是无序的

import threading
import time


def task():
    time.sleep(1)
    print("当前线程:", threading.current_thread().name)


if __name__ == '__main__':

   for _ in range(5):
       sub_thread = threading.Thread(target=task)
       sub_thread.start()

执行结果：

当前线程: Thread-1
当前线程: Thread-2
当前线程: Thread-4
当前线程: Thread-5
当前线程: Thread-3

说明：

线程之间执行是无序的，它是由cpu调度决定的，cpu调度哪个线程，哪个线程就先执行，没有调度的线程不能执行。
进程之间执行也是无序的，它是由操作系统调度决定的，操作系统调度哪个进程，哪个进程就先执行，没有调度的进程不能执行。

2、主线程会等待所有子线程执行结束再结束

假如我们现在创建一个子线程，这个子线程执行完大概需要2.5秒钟，现在让主线程执行1秒钟就退出程序，查看一下执行结果，示例代码如下:

import threading
import time


# 测试主线程是否会等待子线程执行完成以后程序再退出
def show_info():
    for i in range(5):
        print("test:", i)
        time.sleep(0.5)


if __name__ == '__main__':
    sub_thread = threading.Thread(target=show_info)
    sub_thread.start()

    # 主线程延时1秒
    time.sleep(1)
    print("over")

执行结果：

test: 0
test: 1
over
test: 2
test: 3
test: 4

通过上面代码的执行结果，我们可以得知: 主线程会等待所有的子线程执行结束再结束

假如我们就让主线程执行1秒钟，子线程就销毁不再执行，那怎么办呢?

我们可以设置守护主线程 ：守护主线程就是主线程退出子线程销毁不再执行。

设置守护主线程有两种方式：

threading.Thread(target=show_info, daemon=True)
线程对象.setDaemon(True)

设置守护主线程示例：

import threading
import time


# 测试主线程是否会等待子线程执行完成以后程序再退出
def show_info():
    for i in range(5):
        print("test:", i)
        time.sleep(0.5)


if __name__ == '__main__':
    # 创建子线程守护主线程 
    # daemon=True 守护主线程
    # 守护主线程方式1
    sub_thread = threading.Thread(target=show_info, daemon=True)
    # 设置成为守护主线程，主线程退出后子线程直接销毁不再执行子线程的代码
    # 守护主线程方式2
    # sub_thread.setDaemon(True)
    sub_thread.start()

    # 主线程延时1秒
    time.sleep(1)
    print("over")

执行结果：

test: 0
test: 1
over

3、线程之间共享全局变量

需求：

定义一个列表类型的全局变量
创建两个子线程分别执行向全局变量添加数据的任务和向全局变量读取数据的任务
查看线程之间是否共享全局变量数据

import threading
import time


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

python并发编程之多线程
 python并发编程之多线程理论部分
 python 之  并发编程（进程池与线程池同步异步阻塞非阻塞线程queue）
 Python网络编程之线程与进程
 python-学习-python并发编程之多进程与多线程
 python并发编程之多进程