python多线程,自我理解
2020-11-16 本文已影响0人
new和光同尘
前段时间写了自动化程序用到了多线程,当时稀里糊涂的从网上复制粘贴完成的需求,搞完之后,梳理了一下自己的理解,没有晦涩难懂的专业术语,也不说原理,就说怎么用,举例实操,直接切入!
其中两个用到多线程的点
- 同时给20台终端刷机的自动化程序
- 同时给多台终端安装三方应用
我创建线程使用的threading这个库
1. 普通的线程创建
import threading
import time
number = 0
def method(flag):
global number
for loop in range(3):
number += 1
print(flag + ' ' + str(number))
time.sleep(1)
if __name__ == '__main__':
threadList = []
# 创建线程时,target= 调用的函数是不加括号的,
# 不加括号,调用的是函数本身,是整个函数,是函数的一个对象,不用等到函数执行结束,不阻塞
# 加括号, 调用的是函数的执行过程,必须等到函数执行结束,是阻塞主线程的
t1 = threading.Thread(target=method, args=('t1',))
t2 = threading.Thread(target=method, args=('t2',))
threadList.append(t1)
threadList.append(t2)
for i in threadList:
i.start()
print('和光同尘')
这种情况的调用的流程图大概是这样的(根据自己的理解):
2. setDaemon(True) 守护线程
主进程,成为子进程的守护进程,意思就是主进程退出后,不管子进程是否结束,整个程序直接退出,setDeamon(True),在start()之前调用才会生效
比如说,拿手机举例,整个测试过程中要求设备亮屏测试,长时间不操作设备会自动息屏,这个时候我就可以启动一个守护线程判断手机屏幕的状态,只要灭屏,就点亮屏幕,主程序结束后,直接就退出
import threading
import time
number = 0
def method(flag):
global number
for loop in range(3):
number += 1
print(flag + ' ' + str(number))
time.sleep(1)
if __name__ == '__main__':
threadList = []
t1 = threading.Thread(target=method, args=('t1',))
t2 = threading.Thread(target=method, args=('t2',))
threadList.append(t1)
threadList.append(t2)
for i in threadList:
i.setDaemon(True)
i.start()
print('和光同尘')
3. join() 子进程执行结束之后,主进程再继续执行
直接举例,还是拿手机为例,比如:
给10台手机刷机/安装应用,10台手机全部刷完机/安装完应用 之后才能开始测试,创建了10个线程给 手机刷机/安装应用,就需要到join()
import threading
import time
number = 0
def method(flag):
global number
for loop in range(3):
number += 1
print(flag + ' ' + str(number))
time.sleep(1)
if __name__ == '__main__':
threadList = []
t1 = threading.Thread(target=method, args=('t1',))
t2 = threading.Thread(target=method, args=('t2',))
threadList.append(t1)
threadList.append(t2)
for i in threadList:
i.setDaemon(True)
i.start()
for j in threadList:
j.join()
print('和光同尘')
4. 线程锁Lock
直接上例子,比如厕所只有一个蹲坑,同时有一群人在排队,不管多着急,一次只允许进去一个,这个时候就用上线程锁 threading.Lock()
线程锁的方法
acquire()是锁定,类似上述例子中 蹲坑已经被占用,别人用不了了,
release()是释放锁,类似上述例子中蹲坑已经用完,开门出去,别人可以用了
import threading
import time
number = 0
def method(flag, mlock):
global number
mlock.acquire()
for loop in range(3):
number += 1
print(flag + ' ' + str(number))
time.sleep(1)
mlock.release()
if __name__ == '__main__':
threadList = []
lock = threading.Lock()
t1 = threading.Thread(target=method, args=('t1', lock,))
t2 = threading.Thread(target=method, args=('t2', lock,))
threadList.append(t1)
threadList.append(t2)
for i in threadList:
i.setDaemon(True)
i.start()
for j in threadList:
j.join()
print('和光同尘')
5. 允许给定数量的子线程同时做操作BoundedSemaphore(),
用法同Lock也有两个操作方法 acquire() 和 release()
还是上例子,比如这次有3个蹲坑,或者饭店有3个餐桌 ..... 嘿嘿嘿 后续的应该可以脑补出来
import threading
import time
number = 0
def method(flag, mlock):
global number
mlock.acquire()
for loop in range(2):
number += 1
print(flag + ' ' + str(number))
time.sleep(1)
mlock.release()
if __name__ == '__main__':
threadList = []
bound = threading.BoundedSemaphore(3)
t1 = threading.Thread(target=method, args=('t1', bound,))
t2 = threading.Thread(target=method, args=('t2', bound,))
t3 = threading.Thread(target=method, args=('t3', bound,))
t4 = threading.Thread(target=method, args=('t4', bound,))
threadList.append(t1)
threadList.append(t2)
threadList.append(t3)
threadList.append(t4)
for i in threadList:
i.setDaemon(True)
i.start()
for j in threadList:
j.join()
print('和光同尘')
#######################结束######################