python 多线程和锁

import threading
import time

def run(num):
    print(‘Num: %s‘% num)
    time.sleep(3)

    if num == 4:
        print(‘Thread is finished.‘)

# 对函数 run 创建5个线程
for i in range(5):
    # 创建线程，target:目标函数，args:函数的参数，使用元组的形式
    t = threading.Thread(target=run,args=(i,))
    # 开始线程活动
    t.start()

time.sleep(0.01)
print(‘Main thread is finished.‘)

结果：
Num: 0
Num: 1
Num: 2
Num: 3
Num: 4
Main thread is finished.
Thread is finished.

# 上面打印的顺序是先打印 Main thread is finished.因为主线程已经完成了，而子线程里 slee(3)，所以此时子线程尚未完成，大约3秒后，才打印的 Thread is finished.

import threading
import time

def run(num):
    print(‘Num: %s‘% num)
    time.sleep(3)

    if num == 4:
        print(‘Thread is finished.‘)

Tlist = []
for i in range(5):
    # 创建线程，target:目标函数，args:函数的参数，使用元组的形式
    t = threading.Thread(target=run,args=(i,))
    # 开始线程活动
    t.start()
    Tlist.append(t)

for t in Tlist:  # 针对每个子线程，等待子线程执行一段时间，再继续往下执行主线程。
    # t.join(0.1)  # 针对每个子线程，等待0.1秒，继续执行主线程
    t.join()   # 没写时间，则默认等待子线程执行完毕，才继续往下执行主线程。

time.sleep(0.01)
print(‘Main thread is finished.‘)

结果：
Num: 0
Num: 1
Num: 2
Num: 3
Num: 4
Thread is finished.
Main thread is finished.

# 子线程使用了join方法，等待子线程执行完毕才继续执行主线程，所以打印顺序是正常的。

import threading
import time

def run(num):
    print(‘Num: %s‘% num)
    time.sleep(3)

    if num == 4:
        print(‘Thread is finished.‘)

Tlist = []
for i in range(5):
    # 创建线程，target:目标函数，args:函数的参数，使用元组的形式
    t = threading.Thread(target=run,args=(i,))
    # 设置为守护线程
    t.setDaemon(True)
    # 开始线程活动
    t.start()
    Tlist.append(t)

for t in Tlist:  # 针对每个子线程，等待子线程执行一段时间，再继续往下执行主线程。
    t.join(0.1)  # 对子线程等待0.1秒后，继续执行主线程
    # t.join()   # 没写时间，则默认等待子线程执行完毕，才继续往下执行主线程。

time.sleep(0.01)
print(‘Main thread is finished.‘)
print(‘Current Thread:‘,threading.activeCount()) # 打印当前活动线程数量，这是主线程最后一个语句，所以不管此时还有多少个活动的守护线程，当此句执行完毕，守护线程都会被杀掉。

结果：
Num: 0
Num: 1
Num: 2
Num: 3
Num: 4
Main thread is finished.
Current Thread: 6

# 少打印了 Thread is finished. 因为 主线程结束后，子线程就被杀掉了。

import threading

class MyThread(threading.Thread):
    def run(self):  # 这是重写的父类的run方法
        global num
        if mutex.acquire():  # 判断能否加锁，acquire()返回的是加锁的状态，加锁成功就是True
            num = num+1
            msg = self.name+‘ set num to ‘+str(num)
            print(msg)
            # mutex.acquire()   # 这两句话如果不注释掉，就会进入死锁的状态。因为上一个锁还未释放，再次请求加锁，就会阻塞。
            # mutex.release()
            mutex.release()  # 释放锁
num = 0
mutex = threading.Lock()
def test():
    for i in range(5):
        t = MyThread()
        t.start()
if __name__ == ‘__main__‘:
    test()

import threading
import time

def run(n):
    global num
    if mutex.acquire(): # 返回获取锁的结果，加锁成功为True，失败false
        num = num+1
        msg =‘Thread-%s set num to ‘ %n + str(num)
        print(msg)
        mutex.release()
        time.sleep(2)

num = 0
mutex = threading.Lock()

for i in range(5):
    t = threading.Thread(target=run,args=(i+1,))
    t.start()

import threading

class MyThread(threading.Thread):
    def run(self):
        global num
        if mutex.acquire():
            num = num+1
            msg = self.name+‘ set num to ‘+str(num)
            print(msg)
            mutex.acquire()  # 虽然再次acquire，但是并不会阻塞
            mutex.release()
            mutex.release()
num = 0
mutex = threading.RLock()
def test():
    for i in range(5):
        t = MyThread()
        t.start()
if __name__ == ‘__main__‘:
    test()

import threading
import time

def run(n):
    sema.acquire()
    print(‘Thread: %s‘ %n)
    time.sleep(2)
    sema.release()

# 声明信号量，同时允许5个线程执行
sema = threading.BoundedSemaphore(5)

for i in range(20):
    t = threading.Thread(target=run,args=(i+1,))
    t.start()

import threading
import time

# 事件可以控制一个内部标志，通过set方法使其变成True，clear方法使其变成False，为False时wait方法会一直阻塞直到标志为True。
# 这个标志初始时是False

event = threading.Event()
# event.set()    # 设置flag为True
# event.clear()  # 设置flag为False
# event.wait()   # 一直等待（阻塞），直到有线程使用 set 方法将 flag 变成 True
# event.is_set() # 返回flag的值

def boss():
    print(‘Boss: 今天加班5秒钟‘)
    event.clear()   # 清除 flag，使其值变为 false
    time.sleep(5)
    print("Boss: 时间到了，大家回家吧")
    event.set()     # 设置 flag，使其值变为 True


def employee():
    while True:
        if event.is_set():     # 判断：如果 flag 为 True
            print(‘Employee: 回家了!‘)
            break
        else:
            print(‘Emplyee: 工作中，请勿打扰...‘)
            event.wait()      # 如果 flag 为 False，则使用 wait 方法一直等待，直到有线程将其设置为 True


# 创建两个线程，分别为boss和employee，让它们根据 event 进行简单的通讯
b = threading.Thread(target=boss,)
e = threading.Thread(target=employee,)
b.start()
e.start()

结果：
Boss: 今天加班5秒钟
Emplyee: 工作中，请勿打扰...
Boss: 时间到了，大家回家吧
Employee: 回家了!