Python进程和线程

23 天前

数据不会说谎

生活中大数据的魅力和影响

学习目标

1、了解多任务的概念

2、了解进程的概念以及多进程的作用

3、掌握多进程完成多任务的工作原理及案例编写

4、掌握进程编号的获取方式以及进程使用的注意事项

5、了解线程的概念以及多线程的作用

6、掌握多进程完成多任务的工作原理及案例编写

一、多任务的概念

1、举个栗子

思考：我们在使用网盘下载资料的时候，为什么要多个任务同时下载呢？答：多个任务同时执行可以大大提高程序的执行效率

2、提出问题

问题：利用我们目前所学的技术，我们能否实现多任务操作呢？答：不能，因为之前所写的程序都是单任务的，也就是说一个函数或者方法执行完成 , 另外一个函数或者方法才能执行。要想实现多个任务同时执行就需要使用多任务。多任务的最大好处是充分利用CPU资源，提高程序的执行效率。

3、什么是多任务

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

4、多任务的两种表现形式

① 并发 ② 并行

5、并发操作

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

6、并行操作

并行：在一段时间内真正的同时一起执行多个任务。对于多核cpu处理多任务，操作系统会给cpu的每个内核安排一个执行的任务，多个内核是真正的一起同时执行多个任务。这里需要注意多核cpu是并行的执行多任务，始终有多个任务一起执行。

二、进程的概念

1、程序中实现多任务的方式

在Python中，想要实现多任务可以使用多进程来完成。

2、进程的概念

进程（Process）是资源分配的最小单位，它是操作系统进行资源分配和调度运行的基本单位，通俗理解：一个正在运行的程序就是一个进程。例如:正在运行的qq , 微信等他们都是一个进程。

注：一个程序运行后至少有一个进程

3、多进程的作用

☆ 未使用多进程

思考: 图中是一个非常简单的程序 , 一旦运行hello.py这个程序 , 按照代码的执行顺序 , func_a函数执行完毕后才能执行func_b函数 . 如果可以让func_a和func_b同时运行 , 显然执行hello.py这个程序的效率会大大提升 .

☆ 使用了多进程

三、多进程完成多任务

1、多进程完成多任务

① 导入进程包
import multiprocessing
② 通过进程类创建进程对象 
进程对象 = multiprocessing.Process() 
③ 启动进程执行任务
进程对象.start()

2、通过进程类创建进程对象

进程对象 = multiprocessing.Process([group [, target=任务名 [, name]]])

参数说明：

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

3、进程创建与启动的代码

边听音乐边敲代码：

import multiprocessing
import time
def music():
    for i in range(3):
        print('听音乐...')
        time.sleep(0.2)
def coding():
    for i in range(3):
        print('敲代码...')
        time.sleep(0.2)
if __name__ == '__main__':
    music_process = multiprocessing.Process(target=music)
    coding_process = multiprocessing.Process(target=coding)
    music_process.start()
    coding_process.start()

运行结果：

听音乐...
敲代码...
听音乐...
敲代码...
听音乐...
敲代码...

这是一个使用Python multiprocessing模块实现并行任务的代码。代码中定义了两个函数music()和coding()，分别表示听音乐和敲代码这两个任务，每个任务都会执行3次，且每次执行后都会暂停0.2秒。代码通过multiprocessing.Process()方法创建了两个进程music_process和coding_process，每个进程都指定了一个target参数，即对应的任务music或coding。接着通过start()方法启动了这两个进程，它们会异步的同时执行。if name == ' main ':这一行是Python程序入口，用来保证在多进程环境中不会重复启动进程。执行该代码后，会看到两个进程并行执行各自的任务，即打印“听音乐…”和“敲代码…”。

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

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

参数说明：这是Python中的一个函数，用于创建一个进程对象并启动一个新的进程。它的参数包括：

group：指定进程组，通常不需要使用，默认为None。
target：指定进程启动时要执行的函数。必须是可调用的对象。
name：指定进程的名称，通常不需要使用，默认为None。
args：指定传递给目标函数的参数元组。args=(1,2,'anne',)
kwargs：指定传递给目标函数的关键字参数字典。kwargs={'name':'anne','age':18}

案例：args参数和kwargs参数的使用

import multiprocessing
import time
def music(num):
    for i in range(num):
        print('听音乐...')
        time.sleep(0.2)
def coding(count):
    for i in range(count):
        print('敲代码...')
        time.sleep(0.2)
if __name__ == '__main__':
    music_process = multiprocessing.Process(target=music, args=(3,))
    coding_process = multiprocessing.Process(target=coding, kwargs={'count': 3})
    music_process.start()
    coding_process.start()
    music_process.join()
    coding_process.join()

加入join()方法是为了保证主进程在所有子进程执行完毕后再结束，否则主进程会在子进程还没执行完毕就结束了。

在多进程编程中，子进程的执行是异步的，主进程和子进程是并发执行的，如果主进程没有等待子进程执行完毕就结束了，那么子进程可能会被强制终止，导致程序出现异常或者数据丢失等问题。

因此，在启动子进程后，应该调用join()方法等待子进程执行完毕后再结束主进程，以保证程序的正常运行。join()方法会阻塞主进程，直到所有的子进程都执行完毕后才会继续执行主进程。案例：多个参数传递

import multiprocessing
import time
def music(num, name):
    for i in range(num):
        print(name)
        print('听音乐...')
        time.sleep(0.2)
def coding(count):
    for i in range(count):
        print('敲代码...')
        time.sleep(0.2)
if __name__ == '__main__':
    music_process = multiprocessing.Process(target=music, args=(3, '多任务开始'))
    coding_process = multiprocessing.Process(target=coding, kwargs={'count': 3})
    music_process.start()
    coding_process.start()

运行结果：

多任务开始
听音乐...
敲代码...
多任务开始
听音乐...
敲代码...
多任务开始
听音乐...
敲代码...

这段代码实现了多进程并发执行不同任务的示例。具体实现如下：

1. 导入了multiprocessing和time模块。

2. 定义了两个函数：music()和coding()。music()函数通过循环执行num次输出字符串name和“听音乐...”字符串并sleep 0.2秒，模拟“听音乐”任务。coding()函数通过循环执行count次输出“敲代码...”字符串并sleep0.2秒，模拟“敲代码”任务。

3. 在程序主入口中执行两个子进程：music_process和coding_process。其中music_process进程调用music()函数，传入参数num=3和name='多任务开始'，coding_process进程调用coding()函数，传入参数count=3。

4. 启动music_process和coding_process进程。

5. 进程开始并发执行，其中music_process进程输出num次name和“听音乐...”字符串，coding_process进程输出count次“敲代码...”字符串。每次输出之后程序会sleep 0.2秒，以模拟不同的任务执行。 6. 进程执行完毕后程序结束。

四、获取进程编号

1、进程编号的作用

当程序中进程的数量越来越多时 , 如果没有办法区分主进程和子进程还有不同的子进程 , 那么就无法进行有效的进程管理 , 为了方便管理实际上每个进程都是有自己编号的。

2、两种进程编号

① 获取当前进程编号

getpid()

② 获取当前进程的父进程ppid = parent pid

getppid()

3、获取当前进程编号

import os
def work():
    # 获取当前进程的编号
    print('work进程编号', os.getpid())
    # 获取父进程的编号
    print('work父进程的编号', os.getppid())
work()

案例：获取子进程编号

import multiprocessing
import time
import os
def music(num):
    print('music>> %d' % os.getpid())
    for i in range(num):
        print('听音乐...')
        time.sleep(0.2)
def coding(count):
    print('coding>> %d' % os.getpid())
    for i in range(count):
        print('敲代码...')
        time.sleep(0.2)
if __name__ == '__main__':
    music_process = multiprocessing.Process(target=music, args=(3, ))
    coding_process = multiprocessing.Process(target=coding, kwargs={'count': 3})
    music_process.start()
    coding_process.start()

运行结果：

music>> 12232
听音乐...
coding>> 1868
敲代码...
听音乐...
敲代码...
听音乐...
敲代码...

这是一个使用Python的multiprocessing模块创建多进程的例子。

首先，定义了两个函数：music和coding，分别输出进程ID，然后使用for循环和time.sleep语句模拟耗时操作。

其次，在程序的主程序中，使用multiprocessing.Process创建了两个进程music_process和coding_process，分别使用target参数指定要执行的函数，以及args或kwargs参数将要执行函数的参数传递进去。然后调用start方法启动这两个进程，从而在两个进程中同时执行不同的任务。

需要注意的是，使用if name == ' main ' 是为了防止子进程递归创建子进程导致的一系列问题，因为在Windows系统下，所有的Python程序都会自动运行一遍，而在Linux/MacOS系统下则不会。案例：获取父进程与子进程编号

import multiprocessing
import time
import os
def music(num):
    print('music>> %d' % os.getpid())
    print('music主进程>> %d' % os.getppid())
    for i in range(num):
        print('听音乐...')
        time.sleep(0.2)
def coding(count):
    print('coding>> %d' % os.getpid())
    print('music主进程>> %d' % os.getppid())
    for i in range(count):
        print('敲代码...')
        time.sleep(0.2)
if __name__ == '__main__':
    print('主进程>> %d' % os.getpid())
    music_process = multiprocessing.Process(target=music, args=(3, ))
    coding_process = multiprocessing.Process(target=coding, kwargs={'count': 3})
    music_process.start()
    coding_process.start()

运行结果：

主进程>> 15080
music>> 10320
music主进程>> 15080
听音乐...
coding>> 19220
music主进程>> 15080
敲代码...
听音乐...
敲代码...
听音乐...
敲代码...

这段代码使用Python的multiprocessing模块创建了两个进程来模拟听音乐和编写代码两个任务的同时执行。

首先定义了两个函数 music() 和 coding() 分别用于在进程中执行听音乐和编写代码的任务。在函数中使用了 os.getpid() 和 os.getppid() 获取当前进程和父进程的ID。

在代码中使用了 multiprocessing.Process() 函数来创建两个进程。 music_process 进程执行 music() 函数，而 coding_process 进程执行 coding() 函数。

最后，在主进程中使用 .start() 方法启动两个子进程的执行，观察运行结果可以发现， music() 和 coding() 函数的任务在两个子进程中并行执行。

五、进程应用注意点

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

实际上创建一个子进程就是把主进程的资源进行拷贝产生了一个新的进程，这里的主进程和子进程是互相独立的。

案例：

import multiprocessing
my_list = []
def write_data():
    for i in range(3):
        my_list.append(i)
        print('add:', i)
    print(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, 不会对其它进程里面的全局变量产生影响，所以进程之间不共享全局变量，只不过进程之间的全局变量名字相同而已，但是操作的不是同一个进程里面的全局变量。

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

2、主进程与子进程的结束顺序

代码演示：

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.start()
    # 延迟1s
    time.sleep(1)
    print('主进程执行完毕')

执行结果：

这段代码使用了Python的multiprocessing模块来创建并启动一个子进程，同时在主进程中延迟1秒后输出一条信息。具体解释如下：

导入multiprocessing和time模块。
定义一个名为work的函数，函数内部使用for循环和time.sleep()函数模拟一些耗时的工作。
在if name == ' main ':语句块中，创建一个名为work_process的子进程，该进程的目标函数为work。
启动子进程，调用work_process.start()。
使用time.sleep(1)函数在主进程中延迟1秒。
输出一条信息，表示主进程执行完毕。

因为子进程和主进程是并行执行的，所以在主进程延迟1秒后，子进程仍然在执行工作函数中的任务。因此，输出的信息可能会在子进程的输出信息之前或之后，具体取决于操作系统的调度策略

☆ 解决方案一：设置守护进程

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()
    # 延迟1s
    time.sleep(1)
    print('主进程执行完毕')

运行结果：

工作中...
工作中...
工作中...
工作中...
工作中...
主进程执行完毕

这段代码使用了Python的multiprocessing模块，实现了创建一个子进程并在其中执行一个工作函数。

首先定义了一个工作函数work()，该函数会循环执行10次，每次输出“工作中...”，并睡眠0.2秒。在主程序中，首先创建了一个子进程work_process，将work函数作为其target参数传递进去，表示该子进程需要执行work函数。

然后将work_process的daemon属性设置为True，表示该子进程是守护进程，即当主进程退出时，该子进程也会随之退出，不再执行子进程中的代码。接下来启动子进程work_process，子进程开始执行work函数中的代码。

主进程延迟1秒后，输出“主进程执行完毕”，然后退出。由于子进程是守护进程，随着主进程的退出，子进程也会被销毁，不再执行work函数中的代码。

☆ 解决方案二：销毁子进程

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.start()
    # 延迟1s
    time.sleep(1)
    # 让子进程直接销毁，表示终止执行， 主进程退出之前，把所有的子进程直接销毁就可以了
    work_process.terminate()
    print('主进程执行完毕')

提示: 以上两种方式都能保证主进程退出子进程销毁

运行结果：

工作中...
工作中...
工作中...
工作中...
工作中...
主进程执行完毕

这段代码使用了Python的multiprocessing模块，实现了创建一个子进程，让子进程执行一个工作函数work()，并在主进程中控制子进程的运行和终止。具体解释如下：

导入multiprocessing和time模块。
定义一个工作函数work()，该函数会循环执行10次，每次打印一条信息“工作中...”，并休眠0.2秒。
在if name == ' main '条件语句中，创建一个子进程work_process，它的目标函数是work()。
启动子进程work_process，它会开始执行work()函数中的循环语句。
主进程延迟1秒，等待子进程执行一段时间。
调用work_process.terminate()方法，强制终止子进程的执行。
打印出“主进程执行完毕”信息。

总体来说，这段代码展示了如何在Python中使用multiprocessing模块创建和控制子进程的运行和终止。

六、线程的概念

1、线程的概念

在Python中，想要实现多任务还可以使用多线程来完成。

2、为什么使用多线程？

进程是分配资源的最小单位 , 一旦创建一个进程就会分配一定的资源 , 就像跟两个人聊QQ就需要打开两个QQ软件一样是比较浪费资源的 . 线程是程序执行的最小单位 , 实际上进程只负责分配资源 , 而利用这些资源执行程序的是线程 , 也就说进程是线程的容器 , 一个进程中最少有一个线程来负责执行程序。同时线程自己不拥有系统资源，只需要一点儿在运行中必不可少的资源，但它可与同属一个进程的其它线程共享进程所拥有的全部资源。这就像通过一个QQ软件(一个进程)打开两个窗口(两个线程)跟两个人聊天一样 , 实现多任务的同时也节省了资源。

3、多线程的作用

def func_a():
    print('任务A')
def func_b():
    print('任务B')
func_a()
func_b()

☆ 单线程执行

☆ 多线程执行

八、多线程完成多任务

1、多线程完成多任务

① 导入线程模块
import threading
② 通过线程类创建线程对象
线程对象 = threading.Thread(target=任务名) 
② 启动线程执行任务
线程对象.start()

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

2、线程创建与启动代码

单线程案例：

import time
def music():
    for i in range(3):
        print('听音乐...')
        time.sleep(0.2)
def coding():
    for i in range(3):
        print('敲代码...')
        time.sleep(0.2)
if __name__ == '__main__':
    music()
    coding()

多线程案例：

import time
import threading
def music():
    for i in range(3):
        print('听音乐...')
        time.sleep(0.2)
def coding():
    for i in range(3):
        print('敲代码...')
        time.sleep(0.2)
if __name__ == '__main__':
    music_thread = threading.Thread(target=music)
    coding_thread = threading.Thread(target=coding)
    music_thread.start()
    coding_thread.start()

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

参数名	说明
args	以元组的方式给执行任务传参
kwargs	以字典方式给执行任务传参

import time
import threading
def music(num):
    for i in range(num):
        print('听音乐...')
        time.sleep(0.2)
def coding(count):
    for i in range(count):
        print('敲代码...')
        time.sleep(0.2)
if __name__ == '__main__':
    music_thread = threading.Thread(target=music, args=(3, ))
    coding_thread = threading.Thread(target=coding, kwargs={'count': 3})
    music_thread.start()
    coding_thread.start()

在主线程中，通过 music_thread.start() 和 coding_thread.start() 启动两个线程，使它们可以同时运行。由于线程是并发执行的，因此 music() 和 coding() 函数会交替执行，输出相应的信息。

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)
    # 启动线程
    work_thread.start()
    # 延时1s
    time.sleep(1)
    print('主线程执行完毕')

运行结果：

work...
work...
work...
work...
work...
主线程执行完毕
work...
work...
work...
work...
work...

这段代码使用了 Python 的 threading 模块，创建了一个线程 work_thread，执行 work() 函数。 work() 函数会输出 'work...'，并且每次循环会暂停 0.2 秒，循环次数为 10。

在主线程中，通过 work_thread.start() 启动线程，使它可以开始执行。

接着，主线程会延时 1 秒钟，然后输出 '主线程执行完毕'。由于 work_thread 线程需要 2 秒钟才能完成全部工作，因此主线程先于 work_thread 线程执行完毕。

通过使用线程，可以让程序在多个任务之间切换执行，提高程序的效率和响应速度。

☆ 设置守护线程方式一

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.start()
    # 延时1s
    time.sleep(1)
    print('主线程执行完毕')

运行结果：

work...
work...
work...
work...
work...
主线程执行完毕

这段代码使用了Python的 time 和 threading 模块。

首先定义了一个函数 work() ，用于在子线程中执行任务。该函数循环10次，每次输出字符串"work..." ，并使用 time.sleep(0.2) 来模拟任务执行的时间。接下来，在主程序中，创建了一个子线程 work_thread ，并将 work() 函数作为其目标函数，设置了 daemon=True 以将其设置为守护线程。然后，使用 work_thread.start() 启动子线程。

接着，主线程使用 time.sleep(1) 延时1秒，以等待子线程执行任务。最后，主线程输出字符串"主线程执行完毕"。由于子线程被设置为守护线程，当主线程执行完毕后，子线程也会随之结束。

因此，如果没有设置守护线程，子线程将会一直执行下去，直到任务完成或者被手动停止。

☆ 设置守护线程方式二

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)
    # 设置守护主线程
    work_thread.setDaemon(True)
    # 启动线程
    work_thread.start()
    # 延时1s
    time.sleep(1)
    print('主线程执行完毕')

运行结果：

work...
work...
work...
work...
work...
主线程执行完毕

这段代码使用了 Python 的 threading 模块创建了一个子线程，并将其设置为守护主线程，然后启动了该子线程。子线程的工作是输出 'work...' 字符串并休眠 0.2 秒，重复执行 10 次。

在主线程中，代码延时 1 秒后输出 '主线程执行完毕' 字符串。因为子线程被设置为守护主线程，所以当主线程执行完毕后，子线程也会随之结束。如果没有设置子线程为守护主线程，那么主线程执行完毕后，子线程仍然会继续执行，直到完成所有工作。

5、线程间的执行顺序

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

思考：当我们在进程中创建了多个线程，其线程之间是如何执行的呢？按顺序执行？一起执行？还是其他的执行方式呢？

答：线程之间的执行是无序的，验证

☆ 获取当前线程信息

# 通过current_thread方法获取线程对象
current_thread = threading.current_thread()
# 通过current_thread对象可以知道线程的相关信息，例如被创建的顺序
print(current_thread)

☆ 线程间的执行顺序

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

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

6、线程间共享全局变量

☆ 线程间共享全局变量

多个线程都是在同一个进程中 , 多个线程使用的资源都是同一个进程中的资源，因此多线程间是共享全局变量

示例代码：

import threading
import time
my_list = []
def write_data():
    for i in range(3):
        print('add：', i)
        my_list.append(i)
    print(my_list)
def read_data():
    print('read：', my_list)
if __name__ == '__main__':
    write_thread = threading.Thread(target=write_data)
    read_thread = threading.Thread(target=read_data)
    write_thread.start()