• Python21天学习挑战赛Day(8)·多线程（threading模块）（应用）

    ​
    ​

    活动地址：CSDN21天学习挑战赛

    学习日志4——

            1.多任务

    操作系统轮流让各个任务交替执行，表面看为交替执行，但由于CPU执行速度极快，呈现出来的效果和同步执行一样。

            注意：

    ·并发：任务数多于CPU核数，通过操作系统的各种任务调度算法，实现用多个任务“一起”执行（实际上总有一些任务不再执行，因为切换任务速度相当快，看上去一起执行而已）。

    ·并行：任务数小于等于CPU核数，即任务真的是一起执行的。

            2.threading模块

    2.1常用方法——

     2.2Thread类使用说明——

     使用Thread 创建线程方法：

            1.为构造函数传递一个可调用对象

            2.继承Thread类并在子类中重写   _init_()和 run()方法

    2.3线程对象 threading.Thread 的方法和属性 ——

    2.4实例化 threading.Thread()  ——

            2.4.1 单线程执行

    1. #coding=utf-8
    2. import threading
    3. import time
    4.  
    5. def hearing():
    6.     print("干啥啥不行，躺平第一名")
    7.     time.sleep(1)
    8.  
    9. if __name__ == "__main__":
    10.     for i in range(5):
    11.         hearing()

            2.4.2 使用threading模块

    1. #coding=utf-8
    2. import threading
    3. import time
    4.  
    5. def hearing():
    6.     print("干啥啥不行，躺平第一名")
    7.     time.sleep(1)
    8.  
    9. if __name__ == "__main__":
    10.     for i in range(5):
    11.         t=threading.Thread(target=hearing)
    12.         t.start()#启动线程
    13.

            多线程耗时更短，调用start()时，才会真正创建线程，并执行。

            2.4.3 主线程会等待所有子线程结束后结束

    1. #coding=utf-8
    2. import threading
    3. import time
    4. from time import  sleep,ctime
    5.  
    6. def hearing():
    7.     print("干啥啥不行，躺平第一名")
    8.     time.sleep(1)
    9.  
    10. def watching():
    11.     print("吃啥啥不剩，能吃是福")
    12.     time.sleep(1)
    13.  
    14. def saying():
    15.     print("我乐意")
    16.     time.sleep(1)
    17. if __name__ == "__main__":
    18.     for i in range(5):
    19.         print("---开始---:%s"%ctime())
    20.         t1=threading.Thread(target=hearing)
    21.         t2=threading.Thread(target=watching())
    22.         t3=threading.Thread(target=saying())
    23.         t1.start()#启动线程
    24.         t2.start()
    25.         t3.start()
    26.         sleep(2)
    27.         print("---结束---:%s"%ctime())
    28.

    输出——

            2.4.4 查看线程数量

            

    1. #coding=utf-8
    2. import threading
    3. import time
    4. from time import  sleep,ctime
    5.  
    6. def hearing():
    7.     print("干啥啥不行，躺平第一名")
    8.     #time.sleep(1)
    9.  
    10. def watching():
    11.     print("吃啥啥不剩，能吃是福")
    12.     #time.sleep(1)
    13.  
    14. def saying():
    15.     print("我乐意")
    16.     #time.sleep(1)
    17. if __name__ == "__main__":
    18.     for i in range(2):
    19.         print("---开始---:%s"%ctime())
    20.         t1=threading.Thread(target=hearing)
    21.         t2=threading.Thread(target=watching())
    22.         t3=threading.Thread(target=saying())
    23.         t1.start()#启动线程
    24.         t2.start()
    25.         t3.start()
    26.  
    27.         while True:
    28.             length=len(threading.enumerate())
    29.             print("当前运行线程数量：%d"%length)
    30.             if length<=1:
    31.                 break
    32.         #sleep(1)
    33.         print("---结束---:%s"%ctime())
    34.

    运行结果——

    2.5 继承 threading.Thread

             2.5.1 线程执行代码的封装

    1. #coding=utf-8
    2. import threading
    3. import time
    4.  
    5. class MyThread(threading.Thread):
    6.     def run(self):
    7.         for i in range(3):
    8.             time.sleep(1)
    9.             msg = "I'm "+self.name+' @ '+str(i) #name属性中保存的是当前线程的名字
    10.             print(msg)
    11.  
    12.  
    13. if __name__ == '__main__':
    14.     t = MyThread()
    15.     t.start()

     

             2.5.2 线程执行顺序

    1. #coding=utf-8
    2. import threading
    3. import time
    4.  
    5. class MyThread(threading.Thread):
    6.     def run(self):
    7.         for i in range(3):
    8.             time.sleep(1)
    9.             msg = "I'm "+self.name+' @ '+str(i)
    10.             print(msg)
    11. def test():
    12.     for i in range(5):
    13.         t = MyThread()
    14.         t.start()
    15. if __name__ == '__main__':
    16.     test()

    运行结果——

     

             2.5.3 多线程-共享全局变量

    1. from threading import Thread
    2. import time
    3.  
    4. g_num = 100
    5.  
    6. def work1():
    7.     global g_num
    8.     for i in range(3):
    9.         g_num += 1
    10.  
    11.     print("----in work1, g_num is %d---"%g_num)
    12.  
    13.  
    14. def work2():
    15.     global g_num
    16.     print("----in work2, g_num is %d---"%g_num)
    17.  
    18.  
    19. print("---线程创建之前g_num is %d---"%g_num)
    20.  
    21. t1 = Thread(target=work1)
    22. t1.start()
    23.  
    24. #延时一会，保证t1线程中的事情做完
    25. time.sleep(1)
    26.  
    27. t2 = Thread(target=work2)
    28. t2.start()

    运行结果——

             2.5.4列表当作实参传递到线程中

    1. from threading import Thread
    2. import time
    3.  
    4. def work1(nums):
    5.     nums.append(44)
    6.     print("----in work1---",nums)
    7.  
    8.  
    9. def work2(nums):
    10.     #延时一会，保证t1线程中的事情做完
    11.     time.sleep(1)
    12.     print("----in work2---",nums)
    13.  
    14. g_nums = [11,22,33]
    15.  
    16. t1 = Thread(target=work1, args=(g_nums,))
    17. t1.start()
    18.  
    19. t2 = Thread(target=work2, args=(g_nums,))
    20. t2.start()

     

             2.5.5 多线程-全局变量问题

    test1:

    1. import threading
    2. import time
    3.  
    4. g_num = 0
    5.  
    6. def work1(num):
    7.     global g_num
    8.     for i in range(num):
    9.         g_num += 1
    10.     print("----in work1, g_num is %d---"%g_num)
    11.  
    12.  
    13. def work2(num):
    14.     global g_num
    15.     for i in range(num):
    16.         g_num += 1
    17.     print("----in work2, g_num is %d---"%g_num)
    18.  
    19.  
    20. print("---线程创建之前g_num is %d---"%g_num)
    21.  
    22. t1 = threading.Thread(target=work1, args=(100,))
    23. t1.start()
    24.  
    25. t2 = threading.Thread(target=work2, args=(100,))
    26. t2.start()
    27.  
    28. while len(threading.enumerate()) != 1:
    29.     time.sleep(1)
    30.  
    31. print("2个线程对同一个全局变量操作之后的最终结果是:%s" % g_num)

    结果

    test2:

    1. import threading
    2. import time
    3.  
    4. g_num = 0
    5.  
    6. def work1(num):
    7.     global g_num
    8.     for i in range(num):
    9.         g_num += 1
    10.     print("----in work1, g_num is %d---"%g_num)
    11.  
    12.  
    13. def work2(num):
    14.     global g_num
    15.     for i in range(num):
    16.         g_num += 1
    17.     print("----in work2, g_num is %d---"%g_num)
    18.  
    19.  
    20. print("---线程创建之前g_num is %d---"%g_num)
    21.  
    22. t1 = threading.Thread(target=work1, args=(1000000,))
    23. t1.start()
    24.  
    25. t2 = threading.Thread(target=work2, args=(1000000,))
    26. t2.start()
    27.  
    28. while len(threading.enumerate()) != 1:
    29.     time.sleep(1)
    30.  
    31. print("2个线程对同一个全局变量操作之后的最终结果是:%s" % g_num)

    3.线程同步

     4.互斥锁

     threading模块中定义了Lock类，可以方便的处理锁定

    1. # 创建锁
    2. mutex = threading.Lock()
    3.  
    4. # 锁定
    5. mutex.acquire()
    6.  
    7. # 释放
    8. mutex.release()

     

     使用互斥锁完成2个线程对同一个全局变量各加100万次的操作

    1. import threading
    2. import time
    3.  
    4. g_num = 0
    5.  
    6. def test1(num):
    7.     global g_num
    8.     for i in range(num):
    9.         mutex.acquire()  # 上锁
    10.         g_num += 1
    11.         mutex.release()  # 解锁
    12.  
    13.     print("---test1---g_num=%d"%g_num)
    14.  
    15. def test2(num):
    16.     global g_num
    17.     for i in range(num):
    18.         mutex.acquire()  # 上锁
    19.         g_num += 1
    20.         mutex.release()  # 解锁
    21.  
    22.     print("---test2---g_num=%d"%g_num)
    23.  
    24. # 创建一个互斥锁
    25. # 默认是未上锁的状态
    26. mutex = threading.Lock()
    27.  
    28. # 创建2个线程，让他们各自对g_num加1000000次
    29. p1 = threading.Thread(target=test1, args=(1000000,))
    30. p1.start()
    31.  
    32. p2 = threading.Thread(target=test2, args=(1000000,))
    33. p2.start()
    34.  
    35. # 等待计算完成
    36. while len(threading.enumerate()) != 1:
    37.     time.sleep(1)
    38.  
    39. print("2个线程对同一个全局变量操作之后的最终结果是:%s" % g_num)

     

     

     5.死锁

     

    1. import threading
    2. import time
    3.  
    4. class MyThread1(threading.Thread):
    5.     def run(self):
    6.         # 对mutexA上锁
    7.         mutexA.acquire()
    8.  
    9.         # mutexA上锁后，延时1秒，等待另外那个线程 把mutexB上锁
    10.         print(self.name+'----do1---up----')
    11.         time.sleep(1)
    12.  
    13.         # 此时会堵塞，因为这个mutexB已经被另外的线程抢先上锁了
    14.         mutexB.acquire()
    15.         print(self.name+'----do1---down----')
    16.         mutexB.release()
    17.  
    18.         # 对mutexA解锁
    19.         mutexA.release()
    20.  
    21. class MyThread2(threading.Thread):
    22.     def run(self):
    23.         # 对mutexB上锁
    24.         mutexB.acquire()
    25.  
    26.         # mutexB上锁后，延时1秒，等待另外那个线程 把mutexA上锁
    27.         print(self.name+'----do2---up----')
    28.         time.sleep(1)
    29.  
    30.         # 此时会堵塞，因为这个mutexA已经被另外的线程抢先上锁了
    31.         mutexA.acquire()
    32.         print(self.name+'----do2---down----')
    33.         mutexA.release()
    34.  
    35.         # 对mutexB解锁
    36.         mutexB.release()
    37.  
    38. mutexA = threading.Lock()
    39. mutexB = threading.Lock()
    40.  
    41. if __name__ == '__main__':
    42.     t1 = MyThread1()
    43.     t2 = MyThread2()
    44.     t1.start()
    45.     t2.start()

     

     

  • 相关阅读:
    Visual Studio快捷键记录
    go脚本示例
    java---高斯消元---线性方程组（每日一道算法2022.9.20）
    设计模式之概述篇
    Java 客户端调用 WebService 接口的一种方式
    3D着色器(OpenGL)
    jenkins结合k8s部署动态slave
    Android Manifest 标签解析
    worthington细胞分离技术丨生存能力测量优化方案
    JavaSE——遍历Map集合
  • 原文地址：https://blog.csdn.net/weixin_62599885/article/details/126235214