Python并发编程基础 №⑥ 线程队列、守护线程、条件和定时器、线程池、线程的事件和信号量、线程锁

1、线程队列

在线程中也可以使用队列传递数据，原因是它自带锁，方便，保证数据安全！

# 1、队列
# 在线程中也可以使用队列传递数据，原因是它自带锁，方便，保证数据安全！不用每
q = queue.Queue()
q.put(1)
q.put(2)
q.put(3)
print(q.get())  # 队列的特点：先进先出。


# 2.栈 性质的队列
lifo = queue.LifoQueue()
lifo.put(1)
lifo.put(2)
print(lifo.get())  # 栈的特点：先进后出


# 3.带优先级的队列
pq = queue.PriorityQueue()
pq.put((-1, 'a'))
pq.put((1, 'b'))
pq.put((-1, 'c'))


print(pq.get())  # 先比较数字，然后比较后面内容的ascii码，数字一样的话，码小的输出！ #(0, 'a')

2、守护线程

from threading import Thread
import time

def func():
    while True:
        time.sleep(1)
        print('***'*3)

def call():
    time.sleep(5)
    print('call in ....')

thread = Thread(target=func,)
thread.daemon = True  # 开启该子线程的守护线程模式：它会随着主线程的运行完成而结束
thread.start()
t = Thread(target=call,)
t.start()
print('主线程代码执行完毕！')  # 如果主线程下的其他非守护线程没结束，它也不结束

# 对比守护进程：守护进程会随着主进程的代码执行完毕，而结束！

3、线程锁

import time, random
from threading import Lock, Thread

# 这个Lock跟进程中的锁，都是互斥锁。存在如果同时有多把锁的话，有可能产生死锁的问题！

# Lock 互斥锁
total = 10

def func(lock):
    global total
    # lock.acquire()
    tmp = total
    time.sleep(1)  # 放在此处才有效果，10减10次后不是0，数据不安全，虽然cpython计时器中有GIL锁，
    # 同一时刻只能让一个线程访问cpu，但是此时刚好cpu时间片到了，必须释放，其他线程于是可以继续访问的了@ 所以还得加锁，保护数据！
    tmp -= 1
    total = tmp
    # lock.release()

lock = Lock()

t_lst = []
for i in range(10):
    t = Thread(target=func, args=(lock, ))
    t.start()
    t_lst.append(t)

[t.join() for t in t_lst]  # 加锁会等10秒，才会有结果！ 效率降低，但是数据安全

print(total)

# 典型死锁例子：科学家们吃意面
''' 有多位科学家在一起聚餐，可是桌子上只有一盘面和一个叉子；他们又很饿，于是他们开始抢了，
只有同时抢到叉子和盘子的人，才能吃上面！可是大概率的发生的却是：一位抢到叉子，另外一位抢到盘子，都吃不上面了！'''

# 同步锁或互斥锁
# fork_lock = Lock()
# disk_lock = Lock()

# 递归锁
from threading import RLock
fork_lock = disk_lock = RLock()

def eat_noodle(name):
    disk_lock.acquire()    # 与delay中的一定要相反，先拿到盘子
    print(name, '拿到了盘子')
    fork_lock.acquire()
    print(name, '拿到了叉子')
    print(' is eating delicious Italy Noodles')
    fork_lock.release()
    disk_lock.release()

def eat_noodle_delay(name):
    fork_lock.acquire()    # 与上面的函数相反，先拿叉子，这样才会有死锁发生！
    print(name, '拿到了叉子')
    time.sleep(random.randint(1, 3))  # 有延时
    disk_lock.acquire()
    print(name, '拿到了盘子')
    print(name, ' is eating delicious Italy Noodles')
    disk_lock.release()
    fork_lock.release()


Thread(target=eat_noodle, args=('tom', )).start()
Thread(target=eat_noodle_delay, args=('jack',)).start()

Thread(target=eat_noodle, args=('trump',)).start()
Thread(target=eat_noodle_delay, args=('steven',)).start()


# 解决死锁的好办法：用递归锁
from threading import RLock

rlock = RLock()
rlock.acquire()
rlock.acquire()
print('rlock is here')   # 不同于互斥锁，可以执行此句！
rlock.release()
rlock.release()

# 所以用递归锁可以解决上面的死锁问题，
# 直接将两把锁都用递归锁
# fork_lock = disk_lock = RLock()  # 一个钥匙串上的两把钥匙

 

4、条件：Condition 特殊的锁

from threading import Condition, Thread

# acquire release
# 一个条件被创建之初 默认有一个False状态
# False状态 会影响wait一直处于等待状态
# notify(int数据类型)  造钥匙


def func(index, condition):
    condition.acquire()
    condition.wait()  # 等钥匙
    print('在第%s次循环里' % index)
    condition.release()


condition = Condition()  # 默认有一个递归锁

for i in range(12):
    Thread(target=func, args=(i, condition)).start()

while 1:
    try:
        num = int(input('>>>').strip())
        condition.acquire()
        condition.notify(num)  # 制造3把一次性的锁
        condition.release()
    except ValueError:
        print('请输入整数！')
        continue

5、定时器 延迟启动的线程

import time
from threading import Timer

# Timer是继承Thread类的，因此它也可以实现多线程，是延时启动的线程


def sync_time():
    print('与格林威治时间同步！')


while True:
    t = Timer(2, sync_time)
    t.start()
    time.sleep(2)  # 此处不等待2秒，子线程会在等待2秒后不断输出！因为上述代码是不阻塞的，异步进行的！

6、线程池

from concurrent.futures import ThreadPoolExecutor
import time
from concurrent.futures import ProcessPoolExecutor


def run():
    time.sleep(2)
    print(' i am running ')


def func(num):
    time.sleep(1)
    ret = num + 1
    # print(ret)
    return ret


def deal(ret):
    print('-------', ret.result())


pool = ThreadPoolExecutor(max_workers=5)  #  默认 不要超过cpu个数*5


pool.map(run, range(20))  # 没有返回值

t_lst = []
for i in range(20):
    t = pool.submit(func, i)
    t_lst.append(t)

# pool.shutdown()

for t in t_lst:
    print(t.result())   # 一次性拿返回值浪费时间，可以随时取，即不关闭池即可实现！

# 回调函数
for i in range(20):
    t = pool.submit(func, i).add_done_callback(deal)


# 2.线程池ProcessPoolExecutor的用法同上
p_pool = ProcessPoolExecutor(max_workers=7)  # 默认比核数多1
'''形同代码就省略了'''

7、线程的事件 Event

import time
import random
from threading import Thread
from threading import Event

# 复习在进程中事件：
# 创建的是带状态的：False
# 如果此时使用wait方法，就会阻塞！
# 判断状态的方法：is_set()
# 转换状态的方法：set() 设为True clear()设为False

# 进程中举的例子是交通灯
# 线程中不重复了，就举连接数据的例子，一个线程连接，一个线程检查是否连接成功


def check_conn(event):
    time.sleep(random.randint(4, 6))
    event.set()


def conn_db(event):
    count = 0
    while count < 5:
        time.sleep(0.1)
        e.wait(1)
        if event.is_set():
            print('连接数据库成功！')
            break
        else:
            count += 1
            print('第%d次，连接数据库不成功！' % count)
    else:
        raise TimeoutError('连接数据库超时！')


e = Event()

t1 = Thread(target=check_conn, args=(e, ))
t2 = Thread(target=conn_db, args=(e, ))

t1.start()
t2.start()

8、线程的信号量 Semaphore

import time
import random
from threading import Semaphore, Thread
# 回顾进程中的Semaphore，会联想到进ktv的例子，一次只能同时让N个人进去！


def enter_ktv(semaphore, name):
    time.sleep(random.randint(1, 3))
    semaphore.acquire()
    print(name, 'is singing!')
    semaphore.release()


sp = Semaphore(5)   # 一次可以允许5个线程访问函数中的print

for i in range(20):
    t = Thread(target=enter_ktv, args=(sp, i))
    t.start()