简单的线程互斥锁(Semaphore): 同时允许一定数量的线程更改数据,也就是限制每次允许执行的线程数.

import threading,time
semaphore = threading.BoundedSemaphore(5)         #最多允许5个线程同时运行

def run(n):
    semaphore.acquire()                           #添加信号
    time.sleep(1)
    print("运行这个线程中: %s"%n)
    semaphore.release()                           #关闭信号

if __name__ == '__main__':
    for i in range(20):                           #同时执行20个线程
        t = threading.Thread(target=run, args=(i,))
        t.start()

while threading.active_count() != 1:              #等待所有线程执行完毕
    pass
else:
    print('----所有线程执行完毕了---')

import threading,time

class mythreading(threading.Thread):
    def run(self):
        semaphore.acquire()  #获取信号量锁
        print('running the thread:',self.getName())
        time.sleep(2)
        semaphore.release()  #释放信号量锁

if __name__ == "__main__":
    semaphore = threading.BoundedSemaphore(3) # 只运行3个线程同时运行
    for i in range(20):
        t1 = mythreading()
        t1.start()
    t1.join()

线程全局锁(Lock): 添加本全局锁以后,能够保证在同一时间内保证只有一个线程具有权限.

import time
import threading

num = 0                  #定义全局共享变量
thread_list = []         #线程列表
lock = threading.Lock()  #生成全局锁

def SumNumber():
    global num          #在每个线程中获取这个全局变量
    time.sleep(2)
    lock.acquire()      #修改数据前给数据加锁
    num += 1            #每次进行递增操作
    lock.release()      #执行完毕以后,解除锁定


for x in range(50):     #指定生成线程数
    thread = threading.Thread(target=SumNumber)
    thread.start()              #启动线程
    thread_list.append(thread)  #将结果列表加入到变量中

for y in thread_list:           #等待执行完毕.
    y.join()

print("计算结果: ",num)

线程递归锁(RLock): 递归锁和全局锁差不多,递归锁就是在大锁中还要添加个小锁,递归锁是常用的锁.

import threading
import time

num = 0                          #初始化全局变量
lock = threading.RLock()         #设置递归锁

def fun1():
    lock.acquire()              #添加递归锁
    global num
    num += 1
    lock.release()              #关闭递归锁
    return num

def fun2():
    lock.acquire()              #添加递归锁
    res = fun1()
    print("计算结果: ",res)
    lock.release()              #关闭递归锁

if __name__ == "__main__":
    for x in range(10):         #生成10个线程
        thread = threading.Thread(target=fun2)
        thread.start()

while threading.active_count() != 1:   #等待所有线程执行完成
    print(threading.active_count())
else:
    print("所有线程运行完成...")
    print(num)

线程互斥锁量控制并发: 使用BoundedSemaphore定义默认信号10,既可以实现控制单位时间内的程序并发量.

import os,time
import threading

def MyThread(x):
    lock.acquire()       # 上锁
    print("执行数据: {}".format(x))
    lock.release()       # 释放锁
    time.sleep(2)        # 模拟函数消耗时间
    threadmax.release()  # 释放信号,可用信号加1

if __name__ == "__main__":
    # 此处的BoundedSemaphore就是说默认给与10个信号
    threadmax = threading.BoundedSemaphore(10)  # 限制线程的最大数量为10个
    lock = threading.Lock()   # 将锁内的代码串行化(防止print输出乱行)
    ThreadPool = []           # 执行线程池

    for item in range(1,100):
        threadmax.acquire()  # 增加信号,可用信号减1
        thread = threading.Thread(target=MyThread,args=(item,))
        thread.start()
        ThreadPool.append(thread)

    for item in ThreadPool:
        item.join()

线程驱动事件(Event): 线程事件用于主线程控制其他线程的执行,事件主要提供了三个方法set、wait、clear、is_set,分别用于设置检测和清除标志.

import threading
event = threading.Event()

def func(x,event):
    print("函数被执行了: %s 次.." %x)
    event.wait()         # 检测标志位状态,如果为True=继续执行以下代码,反之等待.
    print("加载执行结果: %s" %x)

for i in range(10):      # 创建10个线程
    thread = threading.Thread(target=func,args=(i,event,))
    thread.start()

print("当前状态: %s" %event.is_set())      # 检测当前状态,这里为False
event.clear()                             # 将标志位设置为False,默认为False
temp=input("输入yes解锁新姿势: ")          # 输入yes手动设置为True
if temp == "yes":
    event.set()                           # 设置成True
    print("当前状态: %s" %event.is_set())  # 检测当前状态,这里为True