前段时间写了自动化程序用到了多线程，当时稀里糊涂的从网上复制粘贴完成的需求，搞完之后，梳理了一下自己的理解，没有晦涩难懂的专业术语，也不说原理，就说怎么用，举例实操，直接切入！

其中两个用到多线程的点

• 同时给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('和光同尘')

#######################结束######################