【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

线程和进程对比

目录
相关文章
|
21天前
|
缓存 Java 索引
[Python]知识点
本文主要介绍了Python的一些高级知识点和使用细节,包括pip的使用、内置函数、列表、元组、字典、集合、变量、Lambda表达式、面向对象编程、异常处理、模块及标准库等。文章适合有一定Python基础的读者,重点在于深入理解和掌握Python的高级特性。文中还提供了大量示例代码,帮助读者更好地理解和应用这些知识点。
24 1
[Python]知识点
|
13天前
|
并行计算 数据处理 调度
Python中的并发编程:探索多线程与多进程的奥秘####
本文深入探讨了Python中并发编程的两种主要方式——多线程与多进程,通过对比分析它们的工作原理、适用场景及性能差异,揭示了在不同应用需求下如何合理选择并发模型。文章首先简述了并发编程的基本概念,随后详细阐述了Python中多线程与多进程的实现机制,包括GIL(全局解释器锁)对多线程的影响以及多进程的独立内存空间特性。最后,通过实例演示了如何在Python项目中有效利用多线程和多进程提升程序性能。 ####
|
14天前
|
运维 监控 Python
自动化运维:使用Python脚本简化日常任务
【10月更文挑战第36天】在数字化时代,运维工作的效率和准确性成为企业竞争力的关键。本文将介绍如何通过编写Python脚本来自动化日常的运维任务,不仅提高工作效率,还能降低人为错误的风险。从基础的文件操作到进阶的网络管理,我们将一步步展示Python在自动化运维中的应用,并分享实用的代码示例,帮助读者快速掌握自动化运维的核心技能。
30 3
|
1月前
|
安全 Linux 数据安全/隐私保护
python知识点100篇系列(15)-加密python源代码为pyd文件
【10月更文挑战第5天】为了保护Python源码不被查看,可将其编译成二进制文件(Windows下为.pyd,Linux下为.so)。以Python3.8为例,通过Cython工具,先写好Python代码并加入`# cython: language_level=3`指令,安装easycython库后,使用`easycython *.py`命令编译源文件,最终生成.pyd文件供直接导入使用。
python知识点100篇系列(15)-加密python源代码为pyd文件
|
1月前
|
网络协议 数据库连接 Python
python知识点100篇系列(17)-替换requests的python库httpx
【10月更文挑战第4天】Requests 是基于 Python 开发的 HTTP 库,使用简单,功能强大。然而,随着 Python 3.6 的发布,出现了 Requests 的替代品 —— httpx。httpx 继承了 Requests 的所有特性,并增加了对异步请求的支持,支持 HTTP/1.1 和 HTTP/2,能够发送同步和异步请求,适用于 WSGI 和 ASGI 应用。安装使用 httpx 需要 Python 3.6 及以上版本,异步请求则需要 Python 3.8 及以上。httpx 提供了 Client 和 AsyncClient,分别用于优化同步和异步请求的性能。
python知识点100篇系列(17)-替换requests的python库httpx
|
21天前
|
运维 监控 Linux
自动化运维:如何利用Python脚本优化日常任务##
【10月更文挑战第29天】在现代IT运维中,自动化已成为提升效率、减少人为错误的关键技术。本文将介绍如何通过Python脚本来简化和自动化日常的运维任务,从而让运维人员能够专注于更高层次的工作。从备份管理到系统监控,再到日志分析,我们将一步步展示如何编写实用的Python脚本来处理这些任务。 ##
|
25天前
|
调度 iOS开发 MacOS
python多进程一文够了!!!
本文介绍了高效编程中的多任务原理及其在Python中的实现。主要内容包括多任务的概念、单核和多核CPU的多任务实现、并发与并行的区别、多任务的实现方式(多进程、多线程、协程等)。详细讲解了进程的概念、使用方法、全局变量在多个子进程中的共享问题、启动大量子进程的方法、进程间通信(队列、字典、列表共享)、生产者消费者模型的实现,以及一个实际案例——抓取斗图网站的图片。通过这些内容,读者可以深入理解多任务编程的原理和实践技巧。
51 1
|
1月前
|
Python
Python中的多线程与多进程
本文将探讨Python中多线程和多进程的基本概念、使用场景以及实现方式。通过对比分析,我们将了解何时使用多线程或多进程更为合适,并提供一些实用的代码示例来帮助读者更好地理解这两种并发编程技术。
|
1月前
|
调度 Python
python知识点100篇系列(20)-python协程与异步编程asyncio
【10月更文挑战第8天】协程(Coroutine)是一种用户态内的上下文切换技术,通过单线程实现代码块间的切换执行。Python中实现协程的方法包括yield、asyncio模块及async/await关键字。其中,async/await结合asyncio模块可更便捷地编写和管理协程,支持异步IO操作,提高程序并发性能。协程函数、协程对象、Task对象等是其核心概念。
|
1月前
|
Python Windows
python知识点100篇系列(24)- 简单强大的日志记录器loguru
【10月更文挑战第11天】Loguru 是一个功能强大的日志记录库,支持日志滚动、压缩、定时删除、高亮和告警等功能。安装简单,使用方便,可通过 `pip install loguru` 快速安装。支持将日志输出到终端或文件,并提供丰富的配置选项,如按时间或大小滚动日志、压缩日志文件等。还支持与邮件通知模块结合,实现邮件告警功能。
python知识点100篇系列(24)- 简单强大的日志记录器loguru
下一篇
无影云桌面