【python】多任务编程之线程、进程知识点详细总结

简介: 【python】多任务编程之线程、进程知识点详细总结

多任务的执行方式

进程

概念

python多进程

  • Windows下的main判断

  • process进程类

1. import multiprocessing
2. import time
3. def sing():
4. for i in range(3):
5. print(f"唱歌第{i}次")
6.         time.sleep(0.2)
7. def dance():
8. for i in range(3):
9. print(f"跳舞第{i}次")
10.         time.sleep(0.2)
11. if __name__ == '__main__':
12.     sing_pro = multiprocessing.Process(target=sing)
13.     dance_pro = multiprocessing.Process(target=dance)
14.     sing_pro.start()
15.     dance_pro.start()

注:此时唱歌和跳舞的优先度由系统调度决定(随机)

  • 获取进程id
1. import multiprocessing
2. import time
3. import os
4. def sing():
5. print('sing的父进程id:',os.getppid())
6. for i in range(3):
7. print(f"唱歌第{i}次")
8.         time.sleep(1)
9.         os.kill(os.getpid(),9)
10. #       强制结束进程
11. def dance():
12. for i in range(3):
13. print(f"跳舞第{i}次")
14.         time.sleep(1)
15. if __name__ == '__main__':
16.     sing_pro = multiprocessing.Process(target=sing)
17.     dance_pro = multiprocessing.Process(target=dance)
18. print("sing:", sing_pro)
19. print("dance:", dance_pro)
20.     sing_pro.start()
21.     dance_pro.start()
22. print("main:",os.getpid(),multiprocessing.current_process())

sing: <Process name='Process-1' parent=5920 initial>

dance: <Process name='Process-2' parent=5920 initial>

main: 5920 <_MainProcess name='MainProcess' parent=None started>

跳舞第0次

sing的父进程id: 5920

唱歌第0次

跳舞第1次

跳舞第2次

  • 带参任务的执行
1. import multiprocessing
2. def show(name,age):
3. print(f"姓名:{name},年龄是{age}岁")
4. if __name__ == '__main__':
5.     show_pro1=multiprocessing.Process(target=show("coleak1",19))
6.     show_pro2=multiprocessing.Process(target=show,args=('coleak2',20))
7.     show_pro3=multiprocessing.Process(target=show,kwargs={"age":21,"name":'coleak3'})
8.     show_pro1.start()
9.     show_pro2.start()
10.     show_pro3.start()

姓名:coleak1,年龄是19岁

姓名:coleak2,年龄是20岁

姓名:coleak3,年龄是21岁

  • 注意点
  1. 进程间全局变量不共享
  2. 主进程会等待所有子进程执行结束后再结束
  3. 进程之间执行是无序的,由操作系统调度决定
1. import multiprocessing
2. import time
3. import multiprocessing
4. my_list=list()
5. def add():
6. for i in range(3):
7.         my_list.append(i)
8. print("add:",i)
9.         time.sleep(0.5)
10. print(my_list)
11. def read():
12. print("read:",my_list)
13. if __name__ == '__main__':
14.     p1 = multiprocessing.Process(target=add)
15.     p2 = multiprocessing.Process(target=read)
16.     p1.start()
17.     p1.join()
18. #当前进程等待p1进程执行结束后再执行
19.     p2.start()
20. print("main:",my_list)

add: 0

add: 1

add: 2

[0, 1, 2]

main: []

read: []

1. import multiprocessing
2. import time
3. def test():
4. for i in range(6):
5. print(i)
6.         time.sleep(0.2)
7. if __name__ == '__main__':
8.     p1=multiprocessing.Process(target=test)
9.     p1.start()
10.     time.sleep(0.5)
11. print('over!')

0

1

2

over!

3

4

5

  • 主进程退出,子进程销毁
1. import multiprocessing
2. import time
3. def test():
4. while True:
5. print('执行ing...')
6.         time.sleep(0.2)
7. if __name__ == '__main__':
8.     p1=multiprocessing.Process(target=test)
9.     p1.daemon=True
10. # 子进程守护主进程
11.     p1.start()
12.     time.sleep(0.5)
13. print('over!')

执行ing...

执行ing...

执行ing...

over!

1. import multiprocessing
2. import time
3. def test():
4. while True:
5. print('执行ing...')
6.         time.sleep(0.2)
7. if __name__ == '__main__':
8.     p1=multiprocessing.Process(target=test,name='coleak')
9.     p1.start()
10.     time.sleep(0.5)
11.     p1.terminate()
12. print('over!')

执行ing...

执行ing...

执行ing...

over!

线程

概念

python多线程

1. import threading
2. import time
3. def sing():
4. for i in range(3):
5. print(f"唱歌第{i}次")
6.         time.sleep(0.2)
7. def dance():
8. for i in range(3):
9. print(f"跳舞第{i}次")
10.         time.sleep(0.2)
11. if __name__ == '__main__':
12.     t1=threading.Thread(target=sing)
13.     t2=threading.Thread(target=dance)
14.     t1.start()
15.     t2.start()

唱歌第0次跳舞第0次

唱歌第1次跳舞第1次

唱歌第2次跳舞第2次

1. import threading
2. import time
3. def test():
4.     t=threading.current_thread()
5. print('test:',t)
6. 
7. if __name__ == '__main__':
8. print("main:",threading.current_thread())
9.     t1=threading.Thread(target=test)
10.     t1.start()

main: <_MainThread(MainThread, started 3100)>

test: <Thread(Thread-1 (test), started 10836)>

  • 带参任务

同进程知识点

  • 注意点
  1. 线程之间执行是无序的,由cpu调度决定
  2. 主线程等子线程结束后再结束
  3. 线程之间共享全局变量
  4. 线程之间共享全局变量数据会出错
1. import threading
2. import time
3. def test():
4.     time.sleep(1)
5. print(threading.current_thread())
6. if __name__ == '__main__':
7. for i in range(20):
8.         t=threading.Thread(target=test)
9.         t.start()
  • demon守护主进程
1. import threading
2. import time
3. def test():
4. while True:
5. print('执行ing...')
6.         time.sleep(0.2)
7. if __name__ == '__main__':
8.     p1=threading.Thread(target=test,daemon=True)
9.     p1.start()
10.     time.sleep(0.5)
11. print('over!')
1. import threading
2. import time
3. def test():
4. while True:
5. print('执行ing...')
6.         time.sleep(0.2)
7. if __name__ == '__main__':
8.     p1=threading.Thread(target=test)
9.     p1.setDaemon(True)
10.     p1.start()
11.     time.sleep(0.5)
12. print('over!')

执行ing...

执行ing...

执行ing...

over!

1. import threading
2. import time
3. def test():
4. for i in range(3):
5.         my_list.append(i)
6. print("add:",i)
7. if __name__ == '__main__':
8.     my_list = list()
9.     p1=threading.Thread(target=test)
10.     p1.start()
11.     time.sleep(1)
12. print(my_list)

add: 0

add: 1

add: 2

[0, 1, 2]

1. import threading
2. import time
3. a=0
4. def test1():
5. global a
6. for i in range(1000000):
7.         a+=1
8. def test2():
9. global a
10. for i in range(1000000):
11.         a+=1
12. if __name__ == '__main__':
13.     p1=threading.Thread(target=test1)
14.     p2=threading.Thread(target=test2)
15.     p1.start()
16.     p2.start()
17. print(a)

993031,和正确结果相差了近7000

线程同步方式

线程等待

  • join

互斥锁

  • 概念

  • 使用

1. import threading
2. import time
3. a=0
4. lock=threading.Lock()
5. def test1():
6.     lock.acquire()
7. for i in range(1000000):
8. global a
9.         a+=1
10. # print(a)
11.     lock.release()
12. def test2():
13.     lock.acquire()
14. for i in range(1000000):
15. global a
16.         a+=1
17. # print(a)
18.     lock.release()
19. if __name__ == '__main__':
20.     p1=threading.Thread(target=test1)
21.     p2=threading.Thread(target=test2)
22.     p1.start()
23.     p2.start()
24.     time.sleep(2)
25. print(a,'over')

2000000 over

死锁

1. import threading
2. import time
3. lock=threading.Lock()
4. def get(index):
5.     my_list=[6,5,8,7]
6.     lock.acquire()
7. if index>=len(my_list):
8. print("下标越界",index)
9. return
10. print(my_list[index])
11.     lock.release()
12. 
13. if __name__ == '__main__':
14. for i in range(10):
15.         p=threading.Thread(target=get,args=(i,))
16.         p.start()

6

5

8

7

下标越界 4

  • 改进方案
1. import threading
2. import time
3. lock=threading.Lock()
4. def get(index):
5.     my_list=[6,5,8,7]
6.     lock.acquire()
7. if index>=len(my_list):
8. print("下标越界",index)
9.         lock.release()
10. return
11. print(my_list[index])
12.     lock.release()
13. 
14. if __name__ == '__main__':
15. for i in range(10):
16.         p=threading.Thread(target=get,args=(i,))
17.         p.start()

6

5

8

7

下标越界 4

下标越界 5

下标越界 6

下标越界 7

下标越界 8

下标越界 9

线程和进程对比

coleak
+关注
目录
打赏
0
0
0
0
47
分享
相关文章
如何利用Python杀进程并保持驻留后台检测
本教程介绍如何使用Python编写进程监控与杀进程脚本,结合psutil库实现后台驻留、定时检测并强制终止指定进程。内容涵盖基础杀进程、多进程处理、自动退出机制、管理员权限启动及图形界面设计,并提供将脚本打包为exe的方法,适用于需持续清理顽固进程的场景。
用Python编程基础提升工作效率
一、文件处理整明白了,少加两小时班 (敲暖气管子)领导让整理100个Excel表?手都干抽筋儿了?Python就跟铲雪车似的,哗哗给你整利索!
89 11
[oeasy]python081_ai编程最佳实践_ai辅助编程_提出要求_解决问题
本文介绍了如何利用AI辅助编程解决实际问题,以猫屎咖啡的购买为例,逐步实现将购买斤数换算成人民币金额的功能。文章强调了与AI协作时的三个要点:1) 去除无关信息,聚焦目标;2) 将复杂任务拆解为小步骤,逐步完成;3) 巩固已有成果后再推进。最终代码实现了输入验证、单位转换和价格计算,并保留两位小数。总结指出,在AI时代,人类负责明确目标、拆分任务和确认结果,AI则负责生成代码、解释含义和提供优化建议,编程不会被取代,而是会更广泛地融入各领域。
141 29
【高薪程序员必看】万字长文拆解Java并发编程!(9-2):并发工具-线程池
🌟 ​大家好,我是摘星!​ 🌟今天为大家带来的是并发编程中的强力并发工具-线程池,废话不多说让我们直接开始。
116 0
|
4月前
|
[oeasy]python074_ai辅助编程_水果程序_fruits_apple_banana_加法_python之禅
本文回顾了从模块导入变量和函数的方法,并通过一个求和程序实例,讲解了Python中输入处理、类型转换及异常处理的应用。重点分析了“明了胜于晦涩”(Explicit is better than implicit)的Python之禅理念,强调代码应清晰明确。最后总结了加法运算程序的实现过程,并预告后续内容将深入探讨变量类型的隐式与显式问题。附有相关资源链接供进一步学习。
65 4
Python 高级编程与实战:构建 RESTful API
本文深入探讨了使用 Python 构建 RESTful API 的方法,涵盖 Flask、Django REST Framework 和 FastAPI 三个主流框架。通过实战项目示例,详细讲解了如何处理 GET、POST 请求,并返回相应数据。学习这些技术将帮助你掌握构建高效、可靠的 Web API。
在线编程实现!如何在Java后端通过DockerClient操作Docker生成python环境
以上内容是一个简单的实现在Java后端中通过DockerClient操作Docker生成python环境并执行代码,最后销毁的案例全过程,也是实现一个简单的在线编程后端API的完整流程,你可以在此基础上添加额外的辅助功能,比如上传文件、编辑文件、查阅文件、自定义安装等功能。 只有锻炼思维才能可持续地解决问题,只有思维才是真正值得学习和分享的核心要素。如果这篇博客能给您带来一点帮助,麻烦您点个赞支持一下,还可以收藏起来以备不时之需,有疑问和错误欢迎在评论区指出~
在线编程实现!如何在Java后端通过DockerClient操作Docker生成python环境
Python实用技巧:轻松驾驭多线程与多进程,加速任务执行
在Python编程中,多线程和多进程是提升程序效率的关键工具。多线程适用于I/O密集型任务,如文件读写、网络请求;多进程则适合CPU密集型任务,如科学计算、图像处理。本文详细介绍这两种并发编程方式的基本用法及应用场景,并通过实例代码展示如何使用threading、multiprocessing模块及线程池、进程池来优化程序性能。结合实际案例,帮助读者掌握并发编程技巧,提高程序执行速度和资源利用率。
177 0
Python中的并发编程:探索多线程与多进程的奥秘####
本文深入探讨了Python中并发编程的两种主要方式——多线程与多进程,通过对比分析它们的工作原理、适用场景及性能差异,揭示了在不同应用需求下如何合理选择并发模型。文章首先简述了并发编程的基本概念,随后详细阐述了Python中多线程与多进程的实现机制,包括GIL(全局解释器锁)对多线程的影响以及多进程的独立内存空间特性。最后,通过实例演示了如何在Python项目中有效利用多线程和多进程提升程序性能。 ####
Python中的多线程与多进程
本文将探讨Python中多线程和多进程的基本概念、使用场景以及实现方式。通过对比分析,我们将了解何时使用多线程或多进程更为合适,并提供一些实用的代码示例来帮助读者更好地理解这两种并发编程技术。

推荐镜像

更多
AI助理

你好,我是AI助理

可以解答问题、推荐解决方案等

登录插画

登录以查看您的控制台资源

管理云资源
状态一览
快捷访问