您可以捐助，支持我们的公益事业。

1元 10元 50元





认证码：  验证码,看不清楚?请点击刷新验证码 必填



  求知 文章 文库 Lib 视频 iPerson 课程 认证 咨询 工具 讲座 Model Center   Code  
会员   
   
 
     
   
 
 订阅
Python多线程编程（详细）
 
作者：手可摘星辰不去高声语
   次浏览      次
 2023-5-24
 
编辑推荐:
本文主要介绍了详细的Python多线程编程。
本文来自于CSDN，由火龙果软件Linda编辑，推荐。

一、进程

1.多任务

同一时间内执行多个任务

主要有两种方式：

① 并发（在一段时间内交替去执行多个任务：任务数量大于CPU核心数<切换速度很快>）

② 并行（在一段时间内真正同时一起执行多个任务：任务数量小于或等于CPU核心数）

2.进程

进程（Process）是资源分配的最小单位，它是操作系统进行资源分配和调度运行的基本单位，通俗理解，一个正在运行的程序就是一个进程，例如正在运行的QQ……

程序是静态，进程是动态

3.多进程完成多任务

3.1进程的创建步骤

  1.  ①导入进程包
  2.  import multiprocessing
  3.  
  4. ②通过进程类创建进程对象
  5.  进程对象 = multiprocessing.Process()
  6.  
  7.  ③启动进程执行任务
  8.  进程对象.start(）

 

3.2通过进程类创建进程对象

3.3创建进程和启动的代码

实例：

  1. '''
  2. 时间：2021.8.11
  3. 作者：手可摘星辰不去高声语
  4. 名称：02-使用多进程实现多任务.py
  5. '''
  6.  
  7. # 1.导入包和模块
  8. import multiprocessing
  9. import time
  10.  
  11.  
  12. def sing():
  13.     for i in range(3):
  14.         print("i am sing ooo~")
  15.         time.sleep(0.5)
  16.  
  17.  
  18. def dance():
  19.     for i in range(3):
  20.         print("i am dance lll~")
  21.         time.sleep(0.5)
  22.  
  23.  
  24. if __name__ == '__main__':
  25.     # 2.使用进程类创建进程对象
  26.     # target ：指定进程执行的函数名，不加括号
  27.     sing_process = multiprocessing.Process(target=sing)
  28.     dance_process = multiprocessing.Process(target=dance)
  29.  
  30.     # 3. 使用进程对象启动进程执行指定任务
  31.     sing_process.start()
  32.     dance_process.start()

结果：

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

 

  1. '''
  2. 时间：2021.8.11
  3. 作者：手可摘星辰不去高声语
  4. 名称：03-进程中执行带有参数的任务.py
  5. '''
  6.  
  7. # 1.导入包和模块
  8. import multiprocessing
  9. import time
  10.  
  11.  
  12. def sing(num, name):
  13.     for i in range(num):
  14.         print(name)
  15.         print("---i am sing ooo~")
  16.         time.sleep(0.5)
  17.  
  18.  
  19. def dance(num, name):
  20.     for i in range(num):
  21.         print(name)
  22.         print("i am dance lll~")
  23.         time.sleep(0.5)
  24.  
  25.  
  26. if __name__ == '__main__':
  27.     # 2.使用进程类创建进程对象
  28.     # target:指定进程执行的函数名，不加括号
  29.     # args:使用元组方式给指定任务传参，顺序一致(参数顺序)
  30.     # kwargs:使用字典的方式给指定任务传参，名称一致(参数名称)
  31.     sing_process = multiprocessing.Process(target=sing, args=(3, "猪猪"))
  32.     dance_process = multiprocessing.Process(target=dance, kwargs={"name": "珊珊", "num": 2})
  33.  
  34.     # 3. 使用进程对象启动进程执行指定任务
  35.     sing_process.start()
  36.     dance_process.start()

5.获取进程编号

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

获取进程编号的两种方式：

① 获取当前进程编号

os.getpid()

② 获取当前父进程编号

os.getppid()

6.进程的注意点

6.1主进程会等待所有的子进程执行结束后再结束

  1. '''
  2. 时间：2021.8.11
  3. 作者：手可摘星辰不去高声语
  4. 名称：06-进程注意点.py
  5. '''
  6.  
  7. # 1.导入包和模块
  8. import multiprocessing
  9. import time
  10.  
  11.  
  12. def work():
  13.     # 子进程工作2秒
  14.     for i in range(10):
  15.         print("工作中…")
  16.         time.sleep(0.2)
  17.  
  18.  
  19. if __name__ == '__main__':
  20.     work_process = multiprocessing.Process(target=work)
  21.     work_process.start()
  22.  
  23.     # 主进程睡眠1秒
  24.     time.sleep(1)
  25.     print("主进程执行完……")

6.2设置守护主进程（主完子销）

  1. '''
  2. 时间：2021.8.11
  3. 作者：手可摘星辰不去高声语
  4. 名称：07-进程注意点-设置守护主进程.py
  5. '''
  6.  
  7. # 1.导入包和模块
  8. import multiprocessing
  9. import time
  10.  
  11.  
  12. def work():
  13.     # 子进程工作2秒
  14.     for i in range(10):
  15.         print("工作中…")
  16.         time.sleep(0.2)
  17.  
  18.  
  19. if __name__ == '__main__':
  20.     work_process = multiprocessing.Process(target=work)
  21.     # 设置守护主进程，主进程退出后子进程直接销毁，不再执行子进程的代码
  22.     work_process.daemon = True
  23.     work_process.start()
  24.  
  25.     # 主进程睡眠1秒
  26.     time.sleep(1)
  27.     print("主进程执行完……")

二、多进程实现视频文件夹高并发copy器

  1. '''
  2. 时间：2021.8.11
  3. 作者：手可摘星辰不去高声语
  4. 名称：08-案例-视频文件视频的拷贝.py
  5. '''
  6.  
  7. # 1.导入包和模块
  8. import multiprocessing
  9. import os
  10.  
  11.  
  12. def copy_file(file_name, source_dir, dest_dir):
  13.     print(file_name, "--拷贝的进程pid是：", os.getpid())
  14.     # 1.拼接源文件路径和目标文件所在的路径
  15.     source_path = source_dir + "/" + file_name
  16.     dest_path = dest_dir + "/" + file_name
  17.     # 2.打开源文件和目标文件
  18.     with open(source_path, "rb") as source_file:
  19.         with open(dest_path, "wb") as dest_file:
  20.             # 3.循环读取源文件到目标路径
  21.             while True:
  22.                 data = source_file.read(1024)
  23.                 if data:
  24.                     dest_file.write(data)
  25.                 else:
  26.                     break
  27.  
  28.  
  29.  
  30. if __name__ == '__main__':
  31.     # 1.定义源文件夹和目标文件夹
  32.     source_dir = "源文件夹"
  33.     dest_dir = "目标文件夹"
  34.  
  35.     # 2.创建目标文件夹
  36.     try:
  37.         os.mkdir(dest_dir)
  38.     except:
  39.         print("目标文件夹已经存在！")
  40.  
  41.     # 3.读取源文件夹的文件列表
  42.     file_list = os.listdir(source_dir)
  43.  
  44.     # 4.遍历文件列表实现拷贝
  45.     for file_name in file_list:
  46.         # copy_file(file_name, source_dir, dest_dir)
  47.         # 5.使用多进程实现多任务拷贝
  48.         sub_process = multiprocessing.Process(target=copy_file,
  49.                                               args=(file_name, source_dir, dest_dir))
  50.         sub_process.start()

三、线程

1.多任务

可以通过多线程的方式进行

进程是分配资源的最小单位，一旦创建一个进程就会分配一定的资源（打开两个QQ）

线程是程序执行的最小单元，实际上进程只负责分配资源，而利用这些资源执行程序的是线程，也就是说进程是线程的容器，一个进程中最少有一个线程来负责执行程序

线程自己不拥有系统资源，但可与同属一个进程的其他线程共享进程所拥有的全部资源（一个QQ打开两个chat窗口）

--- > 进程：

--- > 线程：

2.多线程完成多任务

2.1线程的创建步骤

  1.  ①导入线程模块
  2.  import threading
  3.  
  4. ②通过线程类创建进程对象
  5.  线程对象 = threading.Thread(target = 任务名)
  6.  
  7.  ③启动线程执行任务
  8.  线程对象.start()

 

2.2通过线程类创建线程对象

2.3线程创建与启动代码

  1. '''
  2. 时间：2021.8.11
  3. 作者：手可摘星辰不去高声语
  4. 名称：09-使用多线程实现多任务.py
  5. '''
  6.  
  7. import threading
  8. import time
  9.  
  10.  
  11. def sing():
  12.     for i in range(3):
  13.         print("i am sing ooo~")
  14.         time.sleep(0.5)
  15.  
  16.  
  17. def dance():
  18.     for i in range(3):
  19.         print("i am dance lll~")
  20.         time.sleep(0.5)
  21.  
  22.  
  23. if __name__ == '__main__':
  24.     sing_thread = threading.Thread(target=sing)
  25.     dance_thread = threading.Thread(target=dance)
  26.  
  27.     sing_thread.start()
  28.     dance_thread.start()

3.线程执行有参数的任务（和进程基本一样）

  1. '''
  2. 时间：2021.8.11
  3. 作者：手可摘星辰不去高声语
  4. 名称：10-使用多线程实现带参数的任务.py
  5. '''
  6.  
  7. import threading
  8. import time
  9.  
  10.  
  11. def sing(num):
  12.     for i in range(num):
  13.         print("i am sing ooo~")
  14.         time.sleep(0.5)
  15.  
  16.  
  17. def dance(num):
  18.     for i in range(num):
  19.         print("i am dance lll~")
  20.         time.sleep(0.5)
  21.  
  22.  
  23. if __name__ == '__main__':
  24.     sing_thread = threading.Thread(target=sing, args=(3,))
  25.     dance_thread = threading.Thread(target=dance, kwargs={"num": 2})
  26.  
  27.     sing_thread.start()
  28.     dance_thread.start()

4.主线程和子线程的结束顺序

4.1主线程会等待所有的子线程执行结束后再结束（同进程一样）

4.2设置守护子线程（主完子销）（同进程一样）

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

5.线程间的执行顺序

5.1获取当前的线程信息

  1. '''
  2. 时间：2021.8.11
  3. 作者：手可摘星辰不去高声语
  4. 名称：10-线程之间执行的顺序.py
  5. '''
  6.  
  7. import threading
  8. import time
  9.  
  10.  
  11. def task():
  12.     time.sleep(0.5)
  13.     # current_thread:获取当前线程的线程对象
  14.     thread = threading.current_thread()
  15.     print(thread)
  16.  
  17.  
  18. if __name__ == '__main__':
  19.     for i in range(5):
  20.         sub_thread = threading.Thread(target=task)
  21.         sub_thread.start()

四、多线程实现视频文件夹高并发copy器

同进程不一样之处：

  1. '''
  2. 时间：2021.8.11
  3. 作者：手可摘星辰不去高声语
  4. 名称：13-案例-视频文件视频多线程拷贝.py
  5. '''
  6.  
  7. # 1.导入包和模块
  8. import threading
  9. import os
  10.  
  11.  
  12. def copy_file(file_name, source_dir, dest_dir):
  13.     print(file_name, "--拷贝的进程pid是：", os.getpid())
  14.     print(file_name, "--拷贝的线程是：", threading.current_thread())
  15.     # 1.拼接源文件路径和目标文件所在的路径
  16.     source_path = source_dir + "/" + file_name
  17.     dest_path = dest_dir + "/" + file_name
  18.     # 2.打开源文件和目标文件
  19.     with open(source_path, "rb") as source_file:
  20.         with open(dest_path, "wb") as dest_file:
  21.             # 3.循环读取源文件到目标路径
  22.             while True:
  23.                 data = source_file.read(1024)
  24.                 if data:
  25.                     dest_file.write(data)
  26.                 else:
  27.                     break
  28.  
  29.  
  30.  
  31. if __name__ == '__main__':
  32.     # 1.定义源文件夹和目标文件夹
  33.     source_dir = "源文件夹"
  34.     dest_dir = "目标文件夹"
  35.  
  36.     # 2.创建目标文件夹
  37.     try:
  38.         os.mkdir(dest_dir)
  39.     except:
  40.         print("目标文件夹已经存在！")
  41.  
  42.     # 3.读取源文件夹的文件列表
  43.     file_list = os.listdir(source_dir)
  44.  
  45.     # 4.遍历文件列表实现拷贝
  46.     for file_name in file_list:
  47.         # copy_file(file_name, source_dir, dest_dir)
  48.         # 5.使用多线程实现多任务拷贝
  49.         sub_thread = threading.Thread(target=copy_file,
  50.                                               args=(file_name, source_dir, dest_dir))
  51.         sub_thread.start()

五、进程和线程对比

关系对比 线程是依附在进程里面的，没有进程就没有线程

一个进程默认提供一个线程，进程可以创建多个线程

区别对比 创建进程的资源开销比创建线程的资源开销要大，进程可以用多核，但是线程不能用多核

进程是操作系统资源分配的基本单位，线程是CPU调度的基本单位

总结（其他博客总结）

非常详细的一篇博客：Python中线程与进程

 

 
   
次浏览       
相关文章
手机软件测试用例设计实践
手机客户端UI测试分析
iPhone消息推送机制实现与探讨
Android手机开发（一）
相关文档
Android_UI官方设计教程
手机开发平台介绍
android拍照及上传功能
Android讲义智能手机开发
相关课程
Android高级移动应用程序
Android系统开发
Android应用开发
手机软件测试

最新活动计划
SysML和EA系统设计与建模 7-26[特惠]
Python、数据分析与机器学习 8-23[特惠]
软件架构设计方法、案例与实践 8-23[特惠]
嵌入式软件架构设计 8-22[线上]
Linux内核编程及设备驱动 7-25[北京]
 
 
最新文章
简述Matplotlib
Python三维绘图--Matplotlib
Python数据清洗实践
PyTorch实战指南
Python爬虫与数据可视化
最新课程
Python应用开发最佳实践
Python+数据分析+tensorflow
Python 编程方法和应用开发
人工智能+Python＋大数据
Python及数据分析
更多...   
成功案例
某通信设备企业 Python数据分析与挖掘
某银行 人工智能+Python+大数据
某领先数字地图提供商 Python数据分析与机器学习
北京 Python及数据分析
某金融公司 Python编程方法与实践培训
更多...