51Testing软件测试论坛

标题: 面试官问你什么是多线程并发？这样答就对了 [打印本页]
作者: lsekfe    时间: 2021-2-19 10:50
标题: 面试官问你什么是多线程并发？这样答就对了
　1.单线程执行
　　Python的内置模块提供了两个线程模块：threading 和thread。
　　thread是原生的，threading是扩展的。
　　用法：变量 = threading.Thread(target = 执行函数)
　　变量.strart()
　　举个例子：
  1. import threading

  3. #自定义test函数

  5. def test():

  7.     print("test threading")

  9.    

  11. #创建一个单线程，来执行test()函数

  13. t = threading.Thread(target= test)

  15. t.start()
复制代码
结果：

　　2.多线程执行
　　单线程已经会使用，那么多线程还会远吗？
　　多线程只需要通过循环创建多个线程，并通过循环启动执行就可以了。
　　我们来看个例子，为了更直观，我把打印的内容修改成打印时间：

  2. import threading

  4. from datetime import *




  9. #自定义test函数

  11. def test():

  13.     now = datetime.now()  #获取当前时间

  15.     print("打印多线程执行时间:",now)

  17. #自定义thr()函数，来执行多线程

  19. def thr():

  21.     threads = []  #自定义一个空的数组，用来存放线程组

  23.     for i in range(10):  #设置循环10次

  25.         t = threading.Thread(target=test)

  27.         threads.append(t)  #把创建的的线程t，装到threads 数组中

  29.     #启动线程

  31.     for t in threads:

  33.         t.start()

  35. #执行thr()函数进行多并发

  37. if __name__ == "__main__"   :

  39.     thr()
复制代码
打印结果：
　　我们可以看到，我循环执行了10次，这时间相差的太小了，可以忽略不计。
　　如果，我设置1000次，10000次的话，如果还是这样写，是不是需要等待很长时间？服务器的压力会不会增加?资源消耗会不会增加？
　　那如何优化呢？
　　来看这个例子：
　　我们执行1000次并发，把这1000次拆成50个线程，每个线程循环20次，这样是不是就会快很多？
　　我们来看看执行效率。

　　这是直接执行1000次并发的时间。
　　修改后代码：

  1. import threading

  3. from datetime import *




  8. #自定义test函数

  10. def test():

  12.     now = datetime.now()  #获取当前时间

  14.     print("打印多线程执行时间:",now)

  16. #设置50个线程

  18. def looptest():

  20.     for i in range(50):

  22.         test()




  27. #自定义thr()函数，来执行多线程

  29. def thr():

  31.     threads = []  #自定义一个空的数组，用来存放线程组

  33.     for i in range(20):  #设置循环10次

  35.         t = threading.Thread(target=test)

  37.         threads.append(t)  #把创建的的线程t，装到threads 数组中

  39.     #启动线程

  41.     for t in threads:

  43.         t.start()

  45. #执行thr()函数进行多并发

  47. if __name__ == "__main__"   :

  49.     thr()
复制代码
　执行的结果：

　　是不是快很多了。
　　3.守护线程
　　在了解守护线程之前，先来了解下主线程与子线程的区别。
　　主线程与子线程的区别：
　　每个线程都有一个唯一标示符，来区分线程中的主次关系的说法。
　　线程唯一标示符：Thread.CurrentThread.ManagedThreadID;
　　UI界面和Main函数均为主线程。
　　被Thread包含的“方法体”或者“委托”均为子线程。
　　委托可以包含多个方法体，利用this.Invoke去执行。
　　也可以定义多种方法体，放在Thread里面去执行。则此方法?体均为子线程。注意如果要修改UI界面的显示。则需要使用this.Invoke，否则会报异常。
　　Main函数为主线程，id标示符与UI界面主线程相等。
　　对照上面的代码，main()就是主线程，thr()就是子线程。
　　>>即先启动main()，然后执行thr()启动子线程。
　　那么，什么是守护线程呢？
　　>>即当主线程执行完毕后，所有的子线程也被关闭(无论子线程是否执行完成)。默认是不设置守护线程的。
　　但是我们又为什么要用守护线程呢？
　　>>说的直接，就是为了防止死循环。
　　>>因为一个死循环如果不手动停止，我们都知道会一直的循环下去，直到资源耗尽。
　　那么守护线程的用法是什么呢？
　　>>setDaemon()：默认是 False， 需要改成True才能启用。
　　举个例子：

  2. import threading

  4. from datetime import *




  9. #自定义test函数

  11. def test():

  13.     x=0

  15.     while (x ==0):    #修改成死循环

  17.         print(datetime.now())

  19. #自定义thr()函数，来执行多线程

  21. def thr():

  23.     threads = []  #自定义一个空的数组，用来存放线程组

  25.     for i in range(20):  #设置循环10次

  27.         t = threading.Thread(target=test)

  29.         threads.append(t)  #把创建的的线程t，装到threads 数组中

  31.         t.setDaemon(True) # 设置守护线程

  33.     #启动线程

  35.     for t in threads:

  37.         t.start()

  39. #执行thr()函数进行多并发

  41. if __name__ == "__main__"   :

  43.     thr()

  45.     print("守护线程功能启用，end")
复制代码

　　注意一点：
　　setDaemon()必须放在 start()前面才有效果，否则无效果。
　　守护线程的意义是什么呢？
　　守护线程的意义在于处理主线程和子线程的关闭工作。
　　4.阻塞线程
　　强制程序停止，除了运用守护线程，还可以用到 阻塞线程，如果说前者是强硬派，那么后者就属于温柔派。那么我们再来看看阻塞线程。
　　阻塞线程：通过子线程 join()方法来阻塞线程，让主线程等待子线程完成之后再往下执行，等主线程执行完毕后在挂你吧所有子线程。
　　举个例子：

  2. import threading

  4. from datetime import *




  9. def test():

  11.     x =0

  13.     while(x ==0):

  15.         print(datetime.now())




  20. def thr():

  22.     threads = []

  24.     for i in range(10):

  26.         t = threading.Thread(target=test)

  28.         threads.append(t)

  30.         t.setDaemon(True)




  35.     for t in  threads:

  37.         t.start()

  39. for t in threads:

  41.     t.join()




  46. if __name__ == "__main__":

  48.     thr()

  50.     print("阻塞线程功能启动，end")
复制代码
这段代码，是不是让你有一种想喝(灭)水(火)的冲动？？　　那就对了，因为不能停止吗~ ~ ~ ~
　　那，这和什么都不设置不是一样？？？
　　莫着急，其实还是有一点区别的：
　　>>什么都不设置的情况下主线程是执行完的，仅等待子线程执行完，所以会打印end信息。
　　>>而两个都设置的情况下，主线程会因为等待子线程结束而不往下执行，主线程无法执行完成，所以也就是无法关闭子线程，不会打印end信息。
　　对于死循环这种情况，可以在join()设置timeout来控制。
　　即，我们来设置个2秒钟。
  1. for t in threads:

  3.         t.join(2)
复制代码
但是你执行之后，会发现，为啥不是2秒停止，而是20秒才停止，是因为我们执行了10个线程， 而每个线程执行2秒，故10个线程timeout时间就是20秒。　　是不是不太讲究，哎~~没办法，就顺了吧！！
　　那么阻塞线程的意义是啥呢？
　　>>阻塞线程的意义在于控制子线程与主线程的执行顺序！
　　5.并发测试框架
　　最后，来up一个并发测试框架，算是今天学习的一个完美的收尾。
　　没有什么好说的，直接上代码。

  2. # -*- coding: utf-8 -*-

  4. """

  6. @ auth : carl_DJ

  8. @ time : 2020-6-8

  10. """




  15. import threading

  17. from datetime import *




  22. #自定义全局变量需要的线程数,20

  24. thread_num = 20

  26. #自定义全局变量每个线程需要循环的数量,10

  28. one_work_num = 10

  30. #自定义函数test()

  32. def test():

  34.     #编写测试代码

  36.     now = datetime.now()

  38.     print("打印时间戳：",now)

  40.     #设置死循环

  42.     #x =0

  44.     #while (x ==1):

  46.     #    print("打印时间戳：",now)

  48. def working():

  50.     # 引用全局变量

  52.     global one_work_num

  54.     #嵌套执行指定循环次数的 test()函数

  56.     for i in range(0,one_work_num):

  58.         test()

  60. #自定义thr()函数，来执行多线程

  62. def thr():

  64.     #自定义一个空的数组，用来存放线程组

  66.     threads = []

  68.     #设置循环次数为thread_num

  70.     for i in  range(thread_num):

  72.         #将working()函数放入到线程中

  74.         t =threading.Thread(target=working,name="T" + str(i))

  76.         #设置守护线程

  78.         t.setDaemon(True)

  80.         threads.append(t)

  82.     #启动线程并执行

  84.     for t in threads:

  86.         t.start()

  88.     #设置阻塞线程

  90.     for t in  threads:

  92.         t.join(2)

  94. if __name__ == "__main__":

  96.     thr()
复制代码












欢迎光临 51Testing软件测试论坛 (http://bbs.51testing.com/) Powered by Discuz! X3.2