互斥锁介绍

【一】什么是互斥锁

• 互斥锁是一种用于多线程中控制对共享资源访问的机制

  • 其作用是保证在同一时刻只有一个线程在访问共享资源，从而避免多个线程同时读写数据造成的问题。

  • 互斥锁的基本原理实在对共享资源进行访问前加锁，使得其他线程无法访问该资源，当访问完成后再解锁，使得其他线程可以进行访问。

  • 通过这种方式，可以保证同一时间只有一个线程在执行关键代码段，从而保证了数据的安全性。

  • 需要注意的是，互斥锁会带来一些额外的开销

【二】多个进程共享同一打印终端

• 进程之间数据不共享，但是共享同一套文件系统，所以访问同一个文件，或同一个打印终端是可以的

• 但是共享带来的是竞争，竞争就容易导致结果错乱，这就需要加锁处理

【三】示例

【1】为加锁

import multiprocessing
import time
import random
​
​
def work(name):
    print(f"{name} is starting ...")
    time.sleep(random.randint(1,4))
    print(f'{name} is ending ...')
​
​
def main():
    task_list = []
    for i in range(10):
        task = multiprocessing.Process(target=work,args=(i,))
        task.start()
        task_list.append(task)
    [task.join()for task in task_list]
​
​
if __name__ == '__main__':
    main()
    
# 2 is ending ...
# 6 is ending ...
# 3 is ending ...
# 5 is ending ...

【2】加锁

from multiprocessing import Lock
import multiprocessing
import time
import random
​
​
def work(name,lock):
    # 在当前子进程启动之前加锁
    # 进入卫生间里面
    # 锁上门
    lock.acquire()
    print(f"{name} is starting ...")
    time.sleep(random.randint(1,4))
    print(f'{name} is ending ...')
    # 上完厕所，打开锁
    # 子进程释放锁
    lock.release()
​
​
def main():
    # 实例化得到一个锁对象
    lock = Lock()
    task_list = []
    for i in range(10):
        task = multiprocessing.Process(target=work,args=(i,lock))
        task.start()
        task_list.append(task)
    [task.join()for task in task_list]
​
​
if __name__ == '__main__':
    main()
    
    
# 0 is starting ...
# 0 is ending ...
# 1 is starting ...
# 1 is ending ...
# 2 is starting ...
# 2 is ending ...
# 3 is starting ...
# 3 is ending ...

【3】火车购票平台

【1】不加锁

import time
import random
​
ticket_data = {'number': 2}
​
​
# 【一】初始化票的张数
def init_ticket():
    with open('ticket_data.json', 'w') as fp:
        json.dump(fp=fp, obj=ticket_data)
​
​
# 【二】读取当前票的张数
def read_ticket():
    with open('ticket_data.json', 'r') as fp:
        data = json.load(fp=fp)
    return data
​
​
# 买完票更新票的数据
def save_data(data):
    with open('ticket_data.json', 'w') as fp:
        json.dump(obj=data, fp=fp)
​
​
# 查看当前票的数量
def search_ticket(name):
    ticket_number = read_ticket().get('number')
    print(f'now name is {name}, now ticket number is {ticket_number}')
​
​
# 买票
def buy_ticket(name):
​
    ticket_data = read_ticket()
    sleep_time = random.randint(1, 4)
    time.sleep(sleep_time)
    # 【1】判断当前是否有票
    if ticket_data.get('number') > 0:
        # 【2】买票 在原来的数据上 -1
        ticket_data['number'] -= 1
        # 【3】将买完票的数据更新进原本的数据
        save_data(ticket_data)
        print(f'now name is {name}, success buy a ticket')
    else:
        print(f'now name is {name}, failed buy a ticket')
​
​
# 不模拟不买票这种情况
def main(name):
    # 让这个人查票
    search_ticket(name)
    # 让这个人买票
    buy_ticket(name)
​
​
def main_process():
    task_list = []
    for i in range(5):
        task = multiprocessing.Process(target=main, args=(f'name_{i}',))
        task.start()
        task_list.append(task)
    for task in task_list:
        task.join()
​
​
if __name__ == '__main__':
    print(f'qiangpiao starting .... ')
    # 初始化票的数据
    # init_ticket()
    # 有了票才能抢票
    main_process()
    print(f'qiangpiao ending .... ')
    
# 一共只有两张票，可四个人都买到票了，这显然不是我们想要的结果
# now name is name_0, now ticket number is 2
# now name is name_1, now ticket number is 2
# now name is name_2, now ticket number is 2
# now name is name_3, now ticket number is 2
# now name is name_4, now ticket number is 2
# now name is name_1, success buy a ticket
# now name is name_4, success buy a ticket
# now name is name_0, success buy a ticket
# now name is name_2, success buy a ticketnow name is name_3, success buy a ticket

【2】加锁

# 一个数据文件里面存了几张火车票
# 每一位用户可以看到有多少票
# 每一个人都能抢票
​
import time
import random
​
ticket_data = {'number': 2}
​
​
# 【一】初始化票的张数
def init_ticket():
    with open('ticket_data.json', 'w') as fp:
        json.dump(fp=fp, obj=ticket_data)
​
​
# 【二】读取当前票的张数
def read_ticket():
    with open('ticket_data.json', 'r') as fp:
        data = json.load(fp=fp)
    return data
​
​
# 买完票更新票的数据
def save_data(data):
    with open('ticket_data.json', 'w') as fp:
        json.dump(obj=data, fp=fp)
​
​
# 查看当前票的数量
def search_ticket(name):
    ticket_number = read_ticket().get('number')
    print(f'now name is {name}, now ticket number is {ticket_number}')
​
​
# 买票
def buy_ticket(name, lock):
    # 在操作数据之前加锁
    lock.acquire()
    ticket_data = read_ticket()
    sleep_time = random.randint(1, 4)
    time.sleep(sleep_time)
    # 【1】判断当前是否有票
    if ticket_data.get('number') > 0:
        # 【2】买票 在原来的数据上 -1
        ticket_data['number'] -= 1
        # 【3】将买完票的数据更新进原本的数据
        save_data(ticket_data)
        print(f'now name is {name}, success buy a ticket')
    else:
        print(f'now name is {name}, failed buy a ticket')
    lock.release()
​
​
# 不模拟不买票这种情况
def main(name, lock):
    # 让这个人查票
    search_ticket(name)
    # 让这个人买票
    buy_ticket(name, lock)
​
​
# 原本是只有两张票
# 结果发现大家都在抢票
# 并且每一个人看到的都是两张票
def main_process():
    # 互斥锁 大家看票的时候可以看到，买票的时候就不一定能买到了
    # 在加载买票的时候，买票之前加锁，付款之后解锁
    # 【1】实例化得到锁对象
    lock = multiprocessing.Lock()
    task_list = []
    for i in range(5):
        task = multiprocessing.Process(target=main, args=(f'name_{i}', lock))
        task.start()
        task_list.append(task)
    for task in task_list:
        task.join()
​
​
if __name__ == '__main__':
    print(f'qiangpiao starting .... ')
    # 初始化票的数据
    # init_ticket()
    # 有了票才能抢票
    main_process()
    print(f'qiangpiao ending .... ')
    
    
# 只有两个买到了票    
# now name is name_0, now ticket number is 2
# now name is name_1, now ticket number is 2
# now name is name_2, now ticket number is 2
# now name is name_3, now ticket number is 2
# now name is name_4, now ticket number is 2
# now name is name_0, success buy a ticket
# now name is name_1, success buy a ticket
# now name is name_2, failed buy a ticket
# now name is name_3, failed buy a ticket
# now name is name_4, failed buy a ticket

【四】互斥锁的优缺点

【1】优点

• 加锁可以保证多个进程修改同一块数据

  • 同一时间只能有一个任务可以进行修改，即串行的修改

  • 速度慢了一点，但是保证了数据安全

【2】缺点

虽然可以用文件共享数据实现进程通信，但是：

• 效率低（共享数据基于文件，而文件是硬盘上的数据）

• 需要自己加锁处理

【3】优化方案

效率高：多个进程共享一块内存的数据

处理锁的问题：mutiprocessing模块为我们提供的基于消息的IPC通信机制：队列和管道。

【五】行锁和表锁

• 行锁和表锁是数据库中常用的锁定机制

【1】行锁

• 行锁是在对数据库表中的某个数据行进行修改时

  • 一次只允许一个用户操作改行

  • 其他用户如果需要修改改行数据就必须等待

• 通过锁定可以避免多个用户同时修改同一行数据所导致数据不一致

【2】表锁

• 表锁则是当一个用户操作某个数据库时

  • 会锁定整个表，其他用户同时不能操作该表

• 这在一些特殊场景下比如表维护、备份等是非常有用的。

【3】总结

行锁定是比较细粒度的锁定

表锁定则是更为粗粒度的锁定方法