线程进阶

互斥锁与数据安全

线程之间的数据安全的问题：+=   -= 赋值操作不安全   

　　pop，append都是线程安全的　　队列也是数据安全

from threading import Thread,Lock
n = 0
def func(lock):
    global n
    for i in range(1500000):
        lock.acquire()
        n  -= 1
        lock.release()

def func2(lock):
    global n
    for i in range(1500000):
        lock.acquire()
        n += 1
        lock.release()

if __name__ == '__main__':
    t_lst = []
    lock = Lock()
    for i in range(10):
        t2 = Thread(target=func2,args=(lock,))
        t = Thread(target=func,args=(lock,))
        t.start()
        t2.start()
        t_lst.append(t)
        t_lst.append(t2)
    for t in t_lst:
        t.join()
    print('-->',n)
#---> -13500000
#结果不完全正确，数据并不安全

递归锁

import time
from threading import Thread,Lock

noodle_lock = Lock()
fork_lock = Lock()
def eat1(name):
    noodle_lock.acquire()
    print('%s拿到面条了' % name)
    fork_lock.acquire()
    print('%s拿到叉子了' % name)
    print('%s在吃面' % name)
    time.sleep(0.5)
    fork_lock.release()
    print('%s放下叉子' % name)
    noodle_lock.release()
    print('%s放下面' % name)

def eat2(name):
    fork_lock.acquire()
    print('%s拿到叉子了' % name)
    noodle_lock.acquire()
    print('%s拿到面条了' % name)
    print('%s吃面' % name)
    time.sleep(0.5)
    noodle_lock.release()
    print('%s放下面' % name)
    fork_lock.release()
    print('%s放下叉子' % name)

if __name__ == '__main__':
    name_list = ['小明', '小灰']
    name_list2 = ['小花', '小草']
    for name in name_list:
        Thread(target=eat1, args=(name,)).start()
    for name in name_list2:
        Thread(target=eat2, args=(name,)).start()

死锁现象：两把锁   异步的   操作的时候抢到一把锁还要去抢第二把锁（抢到了面还要去抢叉子）

　　　　一个线程抢到一把锁（抢到了面），另一个线程抢到了另一把锁（抢到了叉子），大眼瞪小眼

import time
from threading import Thread,RLock
fork_lock = noodle_lock = RLock()
def eat1(name):
    noodle_lock.acquire()
    print('%s拿到面条了' % name)
    fork_lock.acquire()
    print('%s拿到叉子了' % name)
    print('%s在吃面' % name)
    time.sleep(0.5)
    fork_lock.release()
    print('%s放下叉子' % name)
    noodle_lock.release()
    print('%s放下面' % name)

def eat2(name):
    fork_lock.acquire()
    print('%s拿到叉子了' % name)
    noodle_lock.acquire()
    print('%s拿到面条了' % name)
    print('%s吃面' % name)
    time.sleep(0.5)
    noodle_lock.release()
    print('%s放下面' % name)
    fork_lock.release()
    print('%s放下叉子' % name)

if __name__ == '__main__':
    name_list = ['小明', '小灰']
    name_list2 = ['小花', '小草']
    for name in name_list:
        Thread(target=eat1, args=(name,)).start()
    for name in name_list2:
        Thread(target=eat2, args=(name,)).start()

递归锁可以快速解决互斥锁的死锁问题

　　互斥锁：两把锁，多个线程抢

　　递归锁：一把锁，多个线程抢

但是递归锁并不是一个好的解决方案，死锁的发生不是互斥锁的问题，而是程序员的逻辑导致的，只是递归锁可以快速解决死锁问题

递归锁：迅速恢复服务，递归锁替换成互斥锁

　　　　能够完善代码的逻辑并提高代码的效率

多个线程之间，用完一个资源再用另一个资源，先释放一个资源，再去获取一个资源

信号量

import time
from threading import Semaphore,Thread

def func(index,sem):
    sem.acquire()
    print(index)
    time.sleep(1)
    sem.release()

if __name__ == '__main__':
    sem = Semaphore(5)    #每个执行的个数
    for i in range(10):
        Thread(target=func, args=(i, sem)).start()
#与进程的信号量类似

事件

wait() 等待 事件内的信号变成True     set() 把信号变成True   clear() 把信号变成False   is_set() 判断信号状态是否为True

import time
import random
from threading import Event,Thread
def check(e):
    print('开始检测数据库是否连接')
    time.sleep(random.randint(0, 5))
    e.set()

def connect(e):
    for i in range(3):
        e.wait(0.5)
        if e.is_set():
            print('数据库连接成功')
            break
        else:
            print('尝试连接数据库%s次失败' % (i+1))
    else:
        raise TimeoutError   #三次机会连不上就抛异常

e = Event()
Thread(target=check, args=(e,)).start()
Thread(target=connect, args=(e,)).start()

 条件   Condition

允许一次多少人通过

wait  在门口等待的所有人      notify  控制流量，即每次可以通过的人数

wait  notify  使用前后都需要加锁

from threading import Condition,Thread
def func(con,index):
    print('%s在等待' % index)
    con.acquire()
    con.wait()
    print('%s do something' % index)
    con.release()

con = Condition()
for i in range(10):
    t = Thread(target=func, args=(con, i))
    t.start()
con.acquire()
con.notify_all()  #允许通过所有人
con.release()
#################
count = 10
while count > 0:
    num = int(input('>>>'))
    con.acquire()
    con.notify(num)
    count -= num
    con.release()
#自己输入可以通过多少人

 定时器  Timer

from threading import Timer
def func():
    print('------------>')

t = Timer(3, func)    #定时  3秒后执行func
t.start()
print('主线程')
# 主线程            ------------>

只起一个线程：做定时任务

crontab ： Linux操作系统上做定时任务的工具

队列

线程安全   队列：排队相关的逻辑

与进程的队列类似：q.get()   q.put()   q.put_nowait()   q.get_nowait()

qps  每秒接收的请求数      帮助你维持程序相应的顺序

from queue import LifoQueue
lq = LifoQueue()   #栈---后入先出
lq.put(1)
lq.put(2)
lq.put(3)
lq.put('a')
lq.put('b')
print(lq.get())
print(lq.get())
print(lq.get())
#b     a      3

from queue import PriorityQueue
pq = PriorityQueue()
pq.put((15, 'abc'))
pq.put((5, 'ghi'))
pq.put((11, 'def'))
pq.put((11, 'abc'))
print(pq.get())
print(pq.get())
print(pq.get())
#(5, 'ghi')    (11, 'abc')    (11, 'def')
#按照大小排队，如果一样按照后边的ascii 码排序，只加一个括号只输出第一个
#格式必须一致，如果是数字必须是数字，字母必须是字母，数字字母就是数字字母

 

 

#####################################################

# 线程
# 为什么要有锁
    # 保证数据安全
    # GIL保证只有一个线程能使用CPU
    # 每个线程拥有GIL锁的时间是有限的
        # 当一个线程已经到了GIL轮转的临界点的时候
        # 线程的调度 —— 操作系统的
        # 哪个线程处于就绪状态 —— Cpython解释器控制
        # 数据不安全的本质 ：一句python代码对应了多条cpu指令
        # dis模块查看cpu指令 ： load 读数据 func 放回去的过程
# 互斥锁和递归锁
    # 互斥锁 ：
        # 在一个线程里 只用一个锁的时候 互斥锁
        # 为了提高效率 锁多个资源的时候 应该酌情选用互斥锁
    # 递归锁 ：
        # 在一个线程里 用多个锁的时候 递归锁
        # 实例化一个锁 acquire两次
# 信号量和事件
# 条件和定时器
# 队列：优先级队列，栈，队列
    # mulprocessing 队列 IPC进城之间通信 在文件级别的
    # queue 队列 在内存级别的

import dis
# def func():
#     a = 0
#     a += 1

# dis.dis(func)