0 多任务

  • 多任务：
    • 一个系统可以同时运行多个程序，则该操作系统为多任务操作系统。（Windows、mac、Android）
    • 一个程序可以同事执行多个任务，则该应用程序为多任务应用程序。
    • 默认情况下，CPU的一个核运行一个程序，但实际上会运行多个，假装多任务。
  • 并发：假的多任务。（一个CPU执行多个程序）
  • 并行：真的多任务。（每个CPU执行单个程序）
  • 实现多任务的两种方式：多线程、多进程；

1 threading（线程）

1.1 多线程

  1. # 导入threading模块
  2. import threading
  3. import time
  6. def say_hello():
  7.     print('hello, Peter')
  8.     time.sleep(1)
  11. if __name__ == '__main__':
  12.     for i in range(5):
  13. # 创建对象
  14.         t = threading.Thread(target=say_hello)      # target参数为对某函数做标记，参数中的函数名不包括()
  15. # 创建线程
  16.         t.start()
  1. import threading
  2. import time
  5. def task_1():
  6.     for i in range(20):
  7.         print('task_1 print: %s' % i)
  8.         time.sleep(1)
  11. def task_2():
  12.     for i in range(20):
  13.         print('task_2 print: %s' % i)
  14.         time.sleep(1)
  17. if __name__ == '__main__':
  18.     t1 = threading.Thread(target=task_1)
  19.     t2 = threading.Thread(target=task_2)
  20.     t1.start()
  21.     t2.start()
  22.     for i in range(20):
  23.         print('task_main print: %s' % i)
  24.         time.sleep(1)
  26. # 该模块中，18-20执行的是主线程的打印任务，task_1和task_2微模块中的两个子线程；
  27. # 各线程执行的顺序不确定：执行代码时当前的运行环境可能不同、资源的分配可能不同，导致惨做系统调用顺序不一定一致；
  28. # task_1()或task_2()函数执行结束时，意味着其对应的线程结束；
  29. # 程序开始执行，就会有主线程调用。所有子线线程都结束主线程才会真正结束，即便18-20没有完成；

1.2 线程传参

  1. import threading
  2. import time
  4. def say_hello1(a):
  5.     for i in range(10):
  6.         print('hello', a)
  7.         time.sleep(0.5)
  10. def say_hello2(a1, a2):
  11.     for i in range(10):
  12.         print(a1, 'says that hello', a2)
  13.         time.sleep(0.5)
  16. def main():
  17.     # ------------- <方法一> ------------- #
  18.     b = threading.Thread(target=say_hello1, args=('Peter',))
  19.     # args的参数为元组，单元素后要加，
  20.     b.start()
  22.     # ------------- <方法二> ------------- #
  23.     c = threading.Thread(target=say_hello2, kwargs={'a1': 'Peter', 'a2': 'Joey'})
  24.     # kwargs的参数为字典，key为字符串要带''
  25.     c.start()
  28. if __name__ == '__main__':
  29.     main()

1.3 线程信息

  1. import threading
  2. import time
  5. def thread_job():
  6.     print('\nT1 start\n')
  7.     for i in range(10):         # 执行 0-9
  8.         time.sleep(0.1)
  9.         # print(i)
  10.     print('\nT1 finish\n')
  13. def get_knowledge_of_thread():
  14.     print('当前运行进程数量：%s' % threading.active_count())         # 当时同时进行几个进程
  15.     print('当前运行的所有进程：%s' % threading.enumerate())           # 返回一个列表，包括所有当前进行的进程
  16.     print('正在运行的线程：%s' % threading.current_thread())        # 返回正在运行的线程
  19. def main():
  20.     get_knowledge_of_thread()
  21.     added_thread = threading.Thread(target=thread_job, name='T1')      # target的参数为函数名，且不带有()
  22.     added_thread.start()                # 开始线程
  23.     get_knowledge_of_thread()
  24.     added_thread.join()                 # 结束线程
  25.     get_knowledge_of_thread()            # 可看做所有线程成都运行结束才进行的任务
  28. if __name__ == '__main__':
  29.     main()
  1. C:\Users\ASUS\AppData\Local\Programs\Python\Python38-32\python.exe C:/Users/ASUS/PycharmProjects/pythonProject/test_20220511.py
  2. 当前运行进程数量：1
  3. 当前运行的所有进程：[<_MainThread(MainThread, started 10628)>]
  4. 正在运行的线程：<_MainThread(MainThread, started 10628)>
  6. T1 start
  7. 当前运行进程数量：2
  9. 当前运行的所有进程：[<_MainThread(MainThread, started 10628)>, <Thread(T1, started 6040)>]
  10. 正在运行的线程：<_MainThread(MainThread, started 10628)>
  11. 0
  12. 1
  13. 2
  14. 3
  15. 4
  16. 5
  17. 6
  18. 7
  19. 8
  20. 9
  22. T1 finish
  24. 当前运行进程数量：1
  25. 当前运行的所有进程：[<_MainThread(MainThread, started 10628)>]
  26. 正在运行的线程：<_MainThread(MainThread, started 10628)>
  28. 进程已结束,退出代码0

1.4 互斥锁

  1. import threading
  2. import time
  4. # 定义一个全局变量，用来存储互斥锁
  5. trdl = threading.Lock()     # 注意Luck首字母要大写
  7. def say_hello1(a):
  8.     # 上锁
  9.     trdl.acquire()
  10.     for i in range(10):
  11.         print('hello', a)
  12.         time.sleep(0.5)
  13.     # 解锁
  14.     trdl.release()
  17. def say_hello2(a1, a2):
  18.     # 上锁
  19.     trdl.acquire()
  20.     for i in range(10):
  21.         print(a1, 'says that hello', a2)
  22.         time.sleep(0.5)
  23.     # 解锁
  24.     trdl.release()
  27. def main():
  28.     b = threading.Thread(target=say_hello1, args=('Peter',))
  29.     b.start()
  30.     c = threading.Thread(target=say_hello2, kwargs={'a1': 'Peter', 'a2': 'Joey'})
  31.     c.start()
  33. if __name__ == '__main__':
  34.     main()
  • 在 1.2 的基础上，加上 5/9/14/19/23 行代码，代码会分批执行，现将 say_hello1 全部执行完毕，在一口气执行完 say_hello2；
  • 互斥锁的作用是在执行这段代码时，其它线程全部暂停；
  • 重复使用互斥锁 trdl.acquire 的下场就是程序陷入停顿；

9 参考

【莫烦Python】Threading 学会多线程 Python_哔哩哔哩_bilibili

Python多任务编程 1 线程_哔哩哔哩_bilibili

Python多任务编程 3 互斥锁_哔哩哔哩_bilibili