Python学习 ：多线程 --- 锁

mport time
import threading
def addNum():
    global num # 在每个线程中都获取这个全局变量
    temp = num
    print('--get num:',num )
    time.sleep(0.01)
    num = temp - 1 # 对此公共变量进行-1操作

start = time.time()
num = 100  # 设定一个共享变量
thread_list = []
for i in range(100):
    t = threading.Thread(target=addNum)
    t.start()
    thread_list.append(t)

for t in thread_list: # 等待所有线程执行完毕
    t.join()

print('final num:', num )
end = time.time()
print(end - start)
# 此时并不能获取到正确的答案0
# 100个线程每一个一定都没有执行完就进行了切换，我们说过sleep就等效于IO阻塞，1s之内不会再切换回来，所以最后的结果一定是99.
# 多个线程都在同时操作同一个共享资源，所以造成了资源破坏

import time
import threading

def addNum():
    global num # 在每个线程中都获取这个全局变量
    lock.acquire() # 获取锁
    temp = num
    print('--get num:',num )
    num = temp - 1 # 对此公共变量进行-1操作
    lock.release() # 只有在执行完上述内容才会释放锁

start = time.time()
num = 100  # 设定一个共享变量
thread_list = []
lock = threading.Lock()

for i in range(100):
    t = threading.Thread(target=addNum)
    t.start()
    thread_list.append(t)

for t in thread_list: #等待所有线程执行完毕
    t.join()

print('final num:', num )
end = time.time()
print(end - start)

import threading,time

class myThread(threading.Thread):
    def LoA(self):
        lockA.acquire()
        print(self.name,"got lockA",time.ctime())
        time.sleep(3)
        lockB.acquire()
        print(self.name,"got lockB",time.ctime())
        lockB.release()
        lockA.release()
    def LoB(self):
        lockB.acquire()
        print(self.name,"got lockB",time.ctime())
        time.sleep(2)
        lockA.acquire()
        print(self.name,"got lockA",time.ctime())
        lockA.release()
        lockB.release()
    def run(self):
        self.LoA()
        self.LoB()

if __name__=="__main__":
    lockA=threading.Lock()
    lockB=threading.Lock()
    # 解决方案：添加 lock = threading.RLock()
    # lock = threading.RLock()
    threads=[]
    for i in range(3):
        threads.append(myThread())
    for t in threads:
        t.start()
    for t in threads:
        t.join()
    # 此时线程会卡死，一直等待下去，此时添加递归锁即可解决死锁的问题

import threading,time
class myThread(threading.Thread):
    def run(self):
        if semaphore.acquire(): # 如果上信号量锁就往下进行
            print(self.name)
            time.sleep(5)
            semaphore.release()
if __name__=="__main__":
    semaphore = threading.Semaphore(5) # 一次允许5个线程进行
    # semaphore = threading.BoundedSemaphore(5) # 与上述效果一致
    thrs = []
    for i in range(20): # 开启20个线程
        thrs.append(myThread())
    for t in thrs:
        t.start()

import threading,time
from random import randint

class Producer(threading.Thread):
    def run(self):
        global L
        while True:
            val=randint(0,100)
            print('生产者',self.name,":Append"+str(val),L)
            if lock_con.acquire():
                L.append(val)
                lock_con.notify() # 激活一个线程
                lock_con.release()
            time.sleep(3)
class Consumer(threading.Thread):
    def run(self):
        global L
        while True:
                lock_con.acquire() # wait()过后，从此处开始进行
                if len(L)==0:
                    lock_con.wait() # 进入等待阻塞
                    print('继续进行') # 我们可以看到并没有打印这个话，这说明线程不是从wait()下面继续进行
                print('消费者',self.name,":Delete"+str(L[0]),L)
                del L[0]
                lock_con.release()
                time.sleep(0.25)

if __name__=="__main__":

    L = []
    lock_con = threading.Condition()
    threads = []
    for i in range(5):
        threads.append(Producer())
    threads.append(Consumer())
    for t in threads:
        t.start()
    for t in threads:
        t.join()

import threading,time
import random
def light():
   if not event.isSet():
        event.set() #wait就不阻塞 #绿灯状态
    count = 0
    while True:
        if count < 10:
           print('\033[42;1m--green light on---\033[0m')
        elif count <13:
            print('\033[43;1m--yellow light on---\033[0m')
        elif count <20:
            if event.isSet():
                event.clear()
           print('\033[41;1m--red light on---\033[0m')
        else:
            count = 0
           event.set() # 打开绿灯
        time.sleep(1)
        count += 1

def car(n):
   while 1:
       time.sleep(random.randrange(10))
        if  event.isSet(): # 绿灯
          print("car [%s] is running.." % n)
       else:
           print("car [%s] is waiting for the red light.." %n)

if __name__ == '__main__':
    event = threading.Event()
    Light = threading.Thread(target=light)
    Light.start()
    for i in range(3):
        t = threading.Thread(target=car,args=(i,))
        t.start()