python多线程编程 入门教程
目录
- 一、多任务：
- 1.1 概念：
- 1.2 多任务的优势：
- 1.3 多任务的两种表现形式：
- （1）并发：
- （2）并行：
- 二、进程：
- 2.1 进程的概念：
- 2.2 多进程的作用：
- 2.3 多进程完成多任务：
- （1）进程的创建步骤：
- （2）多进程例子：
- 2.4 进程执行带有参数的任务：
- （1）参数说明：
- （2）例子：
- 2.5 获取进程编号：
- （1）作用：
- （2）获取进程编号的两种方式：
- （3）例子：
- 2.6 进程的注意事项：
- （1）主进程会等待所有的子进程完成才结束：
- （2）设置守护主进程：
- 2.7 多进程-案例：
- （1）需求分析：
- （2）实现步骤：
- （3）文件的拷贝函数实现步骤：
- （4）实现代码：
- 三、线程：
- 3.1 线程的介绍：
- 3.2 多线程的作用：
- 3.3 多线程实现多任务：
- （1）线程的创建步骤：
- （2）多进程例子：
- 3.4 线程执行带有参数的任务：
- （1）参数说明：
- （2）例子：
- 3.5 主线程和子线程的结束顺序：
- （1）主线程会等待所有的子线程完成才结束：
- （2）设置守护主线程：
- 3.6 线程间的执行顺序：
- （1）线程间的执行是无序的：
- （2）例子：
- 3.7 多线程-案例：
- （1）需求分析：
- （2）实现：
- 四、进程和线程对比：
- 4.1 关系对比：
- 4.2 区别对比：
- 4.3 优缺点对比：
在学习多线成编程之前，我们先看看 多任务 的概念。
一、多任务：
1.1 概念：
多任务就是指：同一时间能执行多个任务。比方我们的电脑能一边QQ聊天，一边写论文，还能听歌。
1.2 多任务的优势：
多任务的最大好处是 充分利用CPU资源，提高程序的执行效率。
1.3 多任务的两种表现形式：
（1）并发：
在一段时间内交替去执行多个任务。
例子：
对于单核CPU处理多任务，操作系统轮流让各个任务交替执行。如下图所示：
（2）并行：
在一段时间内真正的同时一起执行多个任务。
例子：
对于多核cpu处理多任务，操作系统会给cpu的每个内核安排一个执行的任务， 多个内核是真正的一起同时执行多个任务。这里需要注意多核cpu是并行的执行多任务，始终有多个任务一起执行。
二、进程：
在python中，想要实现多任务，可以使用多进程来实现。
2.1 进程的概念：
进程(Process) 是资源分配的最小单位，它是操作系统进行资源分配和调度运行的基本单位，通俗理解: 一个正在运行的程序就是一个进程。例如：正在运行的qq,微信等，他们都是一个进程。
注意：一个正在运行的程序才叫进程，而没有运行的程序，只能叫程序，不能叫进程。
同时，一个程序可以有一个或者多个进程。
2.2 多进程的作用：
上图中是一个非常简单的程序，一旦运行hello.py这个程序，按照代码的执行顺序,
func_ a函数执行完毕后才能执行func_ b函数。如果可以让func a和func _b同时运行,显然执行hello.py这个程序的效率会大大提升。
那怎么实现呢？接着看：
如下图所示，当运行hello.py这个程序的时候，先创建一个主进程，之后再创建了一个子进程，让主进程执行func_a，让子进程执行func_b，这样就使用多进程实现了多任务。
2.3 多进程完成多任务：
（1）进程的创建步骤：
- 1、导入进程包：
import multiprocessing
- 2、通过进程类创建进程对象：
进程对象 = multiprocessing.Process(target=任务名)
- 3、启动进程执行任务：
进程对象.start()
（2）多进程例子：
下面程序是单进程，先执行唱歌的函数，再执行跳舞的函数。需要3秒完成。
import time
# 唱歌
def sing():
for i in range(3):
print("唱歌...")
time.sleep(0.5) # 延迟0.5秒
# 跳舞
def dance():
for i in range(3):
print("跳舞...")
time.sleep(0.5)
if __name__ == "__main__":
sing()
dance()
运行结果：
上面的程序怎么使用多进程实现呢？下面的程序实现了多进程实现多任务，我们会发现，只需要1.5秒执行完了，唱歌和跳舞是交替执行的。
# 1.导入进程包
import time
import multiprocessing
# 唱歌
def sing():
for i in range(3):
print("唱歌...")
time.sleep(0.5) # 延迟0.5秒
# 跳舞
def dance():
for i in range(3):
print("跳舞...")
time.sleep(0.5)
if __name__ == "__main__":
# 2.使用进程类创建进程对象
sing_process = multiprocessing.Process(target=sing)
dance_process = multiprocessing.Process(target=dance)
# 3.使用进程对象启动进程执行指定任务
sing_process.start()
dance_process.start()
运行结果：
2.4 进程执行带有参数的任务：
（1）参数说明：
进程对象 = multiprocessing.Process(target=任务名, args, kwargs)
（2）例子：
# 1.导入进程包
import time
import multiprocessing
# 唱歌
def sing(num, name):
for i in range(num):
print(name)
print("唱歌...")
time.sleep(0.5) # 延迟0.5秒
# 跳舞
def dance(num, name):
for i in range(num):
print(name)
print("跳舞...")
time.sleep(0.5)
if __name__ == "__main__":
# 2.使用进程类创建进程对象
# args:使用元组方式给指定任务传参
sing_process = multiprocessing.Process(target=sing, args=(3, "李华"))
# kwargs:使用字典方式给指定任务传参
dance_process = multiprocessing.Process(target=dance, kwargs={
"num": 2, "name":"小明"})
# 3.使用进程对象启动进程执行指定任务
sing_process.start()
dance_process.start()
2.5 获取进程编号：
（1）作用：
当程序中进程的数量越来越多时，如果没有办法区分主进程和子进程还有不同的子进程,那么就无法进行有效的进程管理,为了方便管理实际上每个进程都是有自己的编号。
（2）获取进程编号的两种方式：
- （1）获取当前进程编号：
import os
os.getpid()
- （2）获取当前父进程编号：
import os
os.getppid()
（3）例子：
# 1.导入进程包
import os
import time
import multiprocessing
# 唱歌
def sing(num, name):
print("唱歌进程编号:", os.getpid())
print("唱歌进程的父进程:", os.getppid())
for i in range(num):
print(name)
print("唱歌...")
time.sleep(0.5) # 延迟0.5秒
# 跳舞
def dance(num, name):
print("跳舞进程编号:", os.getpid())
print("跳舞进程的父进程:", os.getppid())
for i in range(num):
print(name)
print("跳舞...")
time.sleep(0.5)
if __name__ == "__main__":
print("主进程的编号:", os.getpid())
# 2.使用进程类创建进程对象
# args:使用元组方式给指定任务传参
sing_process = multiprocessing.Process(target=sing, args=(3, "李华"))
# kwargs:使用字典方式给指定任务传参
dance_process = multiprocessing.Process(target=dance, kwargs={
"num": 2, "name":"小明"})
# 3.使用进程对象启动进程执行指定任务
sing_process.start()
dance_process.start()
运行结果：
2.6 进程的注意事项：
（1）主进程会等待所有的子进程完成才结束：
如下图所示，打开QQ时会创建一个主进程，而QQ里面有两个子进程。主进程会等待所有的子进程完成才结束：
下面看一个例子：
import time
import multiprocessing
def work():
# 子进程会工作2秒钟
for i in range(10):
print("工作中...")
time.sleep(0.2)
if __name__ == "__main__":
work_process = multiprocessing.Process(target=work)
work_process.start()
# 主进程睡眠1秒
time.sleep(1)
print("主进程执行完了...")
运行结果：
我们发现，虽然打印了主进程执行完了，但是程序还没有结束，这就说明：主进程会等待所有的子进程完成才结束。
但是我们都知道，当我们把QQ的主进程关闭时，子进程都结束了。那怎么做才能当主进程结束时，子进程也结束了呢？
（2）设置守护主进程：
这个就是说，每一个子进程都守护主进程，当主进程结束了之后，子进程直接结束，也就是被销毁。
只需要加一句话：
work_process.daemon = True # 设置子进程 守护 主进程
看个完整的例子：
import time
import multiprocessing
def work():
# 子进程会工作2秒钟
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)
print("主进程执行完了...")
运行结果：
2.7 多进程-案例：
（1）需求分析：
（2）实现步骤：
（3）文件的拷贝函数实现步骤：
（4）实现代码：
import os
import multiprocessing
def copy_file(file_name, source_dir, dest_dir):
# 1.拼接源文件路径和目标文件路径
source_path = source_dir + "/" + file_name
dest_path = dest_dir + "/" + file_name
# 2.打开源文件和目标文件
with open(source_path, "rb") as source_file:
with open(dest_path, "wb") as dest_file:
# 3.循环读取源文件到目标文件
while True:
data = source_file.read(1024)
if data: # 没到文件的最后一行
dest_file.write(data)
else: # 为空，则说明到最后一行
break
if __name__ == "__main__":
# 1.定义源文件夹和目标文件夹
source_dir = r"python视频"
dest_dir = r"/home/python/桌面/test"
# 2.创建目标文件夹
try:
os.mkdir(dest_dir)
except:
print("目标文件夹已经存在，未创建")
# 3.读取源文件的文件列表
file_list = os.listdir(source_dir)
# 4.遍历文件列表实现拷贝
for file_name in file_list:
# copy_file(file_name, source_dir,dest_dir) # 这个实现是单任务的拷贝
# 5.使用多进程实现多任务拷贝
sub_process = multiprocessing.Process(target=copy_file,
args=(file_name, source_dir, dest_dir))
sub_process.start()
三、线程：
3.1 线程的介绍：
进程是分配资源的最小单位，一旦创建一个进程就会分配一 定的资源，就像跟两个人聊QQ就需要打开两个QQ软件一样是比较浪费资源的。
线程是程序执行的最小单位，实际上进程只负责分配资源，而利用这些资源执行程序的是线程，也就说进程是线程的容器。一个进程中最少有一一个线程来负责执行程序，同时线程自己不拥有系统资源，只需要一点儿在运行中必不可少的资源，但它可与同属一个进程的其它线程共享进程所拥有的全部资源。这就像通过一个QQ软件(一个进程)打开两个窗口(两个线程)跟两个人聊天一样，实现多任务的同时也节省了资源。
3.2 多线程的作用：
将上图中的程序使用多线程实现，怎么做呢？为此我们先看一下，单线程是怎么实现的：
如下图，单线程是按照顺序实现的，也就是说进程中默认有一个线程用来执行程序，我们称之为主线程。
如何使用多线程实现呢？和前面的进程一样，用主线程执行func_a，再创建一个子线程执行func_b。
3.3 多线程实现多任务：
（1）线程的创建步骤：
- 1、导入线程包：
import threading
- 2、通过线程类创建线程对象：
线程对象 = threading.Thread(target=任务名)
- 3、启动线程执行任务：
线程对象.start()
（2）多进程例子：
下面程序是单线程，先执行唱歌的函数，再执行跳舞的函数。需要3秒完成。
import time
# 唱歌
def sing():
for i in range(3):
print("唱歌...")
time.sleep(0.5) # 延迟0.5秒
# 跳舞
def dance():
for i in range(3):
print("跳舞...")
time.sleep(0.5)
if __name__ == "__main__":
sing()
dance()
运行结果：
上面的程序怎么使用多线程实现呢？下面的程序实现了多线程实现多任务，我们会发现，只需要1.5秒执行完了，唱歌和跳舞是交替执行的。
# 1.导入进程包
import time
import threading
# 唱歌
def sing():
for i in range(3):
print("唱歌...")
time.sleep(0.5) # 延迟0.5秒
# 跳舞
def dance():
for i in range(3):
print("跳舞...")
time.sleep(0.5)
if __name__ == "__main__":
# 2.使用进程类创建进程对象
sing_thread = threading.Thread(target=sing)
dance_thread = threading.Thread(target=dance)
# 3.使用进程对象启动进程执行指定任务
sing_thread.start()
dance_thread.start()
运行结果：
3.4 线程执行带有参数的任务：
（1）参数说明：
进程对象 = threading.Thread(target=任务名, args, kwargs)
（2）例子：
# 1.导入进程包
import time
import threading
# 唱歌
def sing(num, name):
for i in range(num):
print(name)
print("唱歌...")
time.sleep(0.5) # 延迟0.5秒
# 跳舞
def dance(num, name):
for i in range(num):
print(name)
print("跳舞...")
time.sleep(0.5)
if __name__ == "__main__":
# 2.使用进程类创建进程对象
# args:使用元组方式给指定任务传参
sing_thread = threading.Thread(target=sing, args=(3, "李华"))
# kwargs:使用字典方式给指定任务传参
dance_thread = threading.Thread(target=dance, kwargs={
"num": 2, "name":"小明"})
# 3.使用进程对象启动进程执行指定任务
sing_thread.start()
dance_thread.start()
3.5 主线程和子线程的结束顺序：
（1）主线程会等待所有的子线程完成才结束：
下面的例子说明了主线程会等待所有的子线程完成才结束。
import time
import threading
def work():
# 子进程会工作2秒钟
for i in range(10):
print("工作中...")
time.sleep(0.2)
if __name__ == "__main__":
work_thread = threading.Thread(target=work)
work_thread.start()
# 主进程睡眠1秒
time.sleep(1)
print("主线程执行完了...")
运行结果：
我们发现，虽然打印了主线程执行完了，但是程序还没有结束，这就说明：主线程会等待所有的子线程完成才结束。
但是我们希望主线程结束了，则所有的子线程都结束，那怎么做呢？接着看：
（2）设置守护主线程：
- 方法一：
只需要加一句话：
work_process.daemon = True # 设置子线程 守护 主进程
- 方法二：
work_thread = threading.Thread(target=work, daemon=True) # 设置子线程 守护 主进程
看个完整的例子：
import time
import threading
def work():
# 子进程会工作2秒钟
for i in range(10):
print("工作中...")
time.sleep(0.2)
if __name__ == "__main__":
# 方法一：
work_thread = threading.Thread(target=work, daemon=True) # 设置子进程 守护 主进程
# 方法二：
work_thread.daemon = True # 设置子进程 守护 主进程
work_thread.start()
# 主进程睡眠1秒
time.sleep(1)
print("主线程执行完了...")
运行结果：
3.6 线程间的执行顺序：
（1）线程间的执行是无序的：
下图是一个进程创建的三个线程，这三个线程的执行顺序是无序的，与创建的顺序无关，它与操作系统的调度有关。
看一个例子：
（2）例子：
我们发现，运行的结果和线程的创建顺序并不一样，所以证明：线程间的执行是无序的。
import threading
import time
def task():
time.sleep(1) # 延迟一秒
# current_thread:获取当前线程的对象
thread = threading.current_thread() # 获取当前的线程
print(thread)
if __name__ == "__main__":
for i in range(5): # 创建5个线程
sub_thread = threading.Thread(target=task)
sub_thread.start()
运行结果：
3.7 多线程-案例：
（1）需求分析：
（2）实现：
由于实现的步骤和多进程是一样的，所有接下来直接看代码，注释在代码中：
import os
import threading
def copy_file(file_name, source_dir, dest_dir):
# 1.拼接源文件路径和目标文件路径
source_path = source_dir + "/" + file_name
dest_path = dest_dir + "/" + file_name
# 2.打开源文件和目标文件
with open(source_path, "rb") as source_file:
with open(dest_path, "wb") as dest_file:
# 3.循环读取源文件到目标文件
while True:
data = source_file.read(1024)
if data: # 没到文件的最后一行
dest_file.write(data)
else: # 为空，则说明到最后一行
break
if __name__ == "__main__":
# 1.定义源文件夹和目标文件夹
source_dir = r"python视频"
dest_dir = r"/home/python/桌面/test"
# 2.创建目标文件夹
try:
os.mkdir(dest_dir)
except:
print("目标文件夹已经存在，未创建")
# 3.读取源文件的文件列表
file_list = os.listdir(source_dir)
# 4.遍历文件列表实现拷贝
for file_name in file_list:
# copy_file(file_name, source_dir,dest_dir) # 这个实现是单任务的拷贝
# 5.使用多线程实现多任务拷贝
sub_thread = threading.Thread(target=copy_file,
args=(file_name, source_dir, dest_dir))
sub_thread.start()
四、进程和线程对比：
4.1 关系对比：
4.2 区别对比：
4.3 优缺点对比：
