进程与线程的同步与互斥

理论

1.通信方法
线程间使用全局变量进行通信

2.共享资源争夺

1. 共享资源：多个进程或者线程都可以操作的资源称为共享资源。对共享资源的操作代码段称为临界区。
2. 影响 ： 对共享资源的无序操作可能会带来数据的混乱，或者操作错误。此时往往需要同步互斥机制协调操作顺序。

3.同步互斥机制

1. 同步 ： 同步是一种协作关系，为完成操作，多进程或者线程间形成一种协调，按照必要的步骤有序执行操作.
   
2. 互斥 ： 互斥是一种制约关系，当一个进程或者线程占有资源时会进行加锁处理，此时其他进程线程就无法操作该资源，直到解锁后才能操作。

注意

1. 一般进程用同步
2. 一般线程用互斥

线程同步互斥方法

1.线程Event

使用

1. from threading import Event
2. e = Event() 创建线程event对象
3. e.wait([timeout]) 阻塞等待e被set
4. e.set() 设置e，使wait结束阻塞
5. e.clear() 使e回到未被设置状态
6. e.is_set() 查看当前e是否被设置

"""
    event 线程同步与互斥
"""
from threading import Event, Thread

# 创建一个event对象
e = Event()
# e.wait()
# 在线程之间进行通信
s = None


def yzr():
    print("杨子荣前来拜山头")
    global s
    s = "天王盖地虎"
    # 为主线程解除阻塞
    e.set()


t = Thread(target=yzr())
t.start()

# 主线程验证信息
print("说对口令就是自己人")
# 在主线程使用之前先阻塞
e.wait()
if s == "天王盖地虎":
    print("宝塔镇河妖")
    print("对的")
else:
    print("死")

t.join()

2.线程锁Lock

使用

1. from threading import Lock
2. lock = Lock() 创建锁对象
3. lock.acquire() 上锁 如果lock已经上锁再调用会阻塞
4. lock.release() 解锁
5. with lock: 上锁
   …
   …
   with代码块结束自动解锁
   注意：每个需要使用共享资源的线程都需要进行上锁和解锁

"""
    线程同步互斥之线程锁 Lock
    注意:
        每个需要使用共享资源的线程都需要进行上锁和解锁
"""
from threading import Thread, Lock

a = b = 0
# 创建线程锁对象
lock = Lock()


# 线程函数
def value():
    while True:
        lock.acquire()
        if a != b:
            print("a = %d,b = %d" % (a, b))
        lock.release()


t = Thread(target=value)
t.daemon = True
t.start()

while True:
    # lock.acquire()
    # a += 1
    # b += 1
    # lock.release()
    with lock:
        a += 1
        b += 1

# t.join()


"""
    有两个线程，同时运行
    1个线程打印1-52这52个数字
    另一个线程打印A-Z这26个字母
    希望通过互斥机制的控制，让打印结果为12A34B56C......5152Z
"""

from threading import Thread, Lock

lock01 = Lock()
lock02 = Lock()


def print_A_Z():
    for x in range(ord('A'), ord('Z') + 1):
        lock02.acquire()
        print(chr(x), end="")
        lock01.release()


def print_1_52():
    for i in range(1, 53, 2):
        lock01.acquire()
        print(i, end="")
        print(i + 1, end="")
        lock02.release()


t1 = Thread(target=print_1_52)
t2 = Thread(target=print_A_Z)
lock02.acquire()
t1.start()
t2.start()
t1.join()
t2.join()

死锁

定义：
死锁是指两个或两个以上的线程在执行过程中，由于竞争资源或者由于彼此通信而造成的一种阻塞的现象，若无外力作用，它们都将无法推进下去。此时称系统处于死锁状态或系统产生了死锁。

死锁的产生原因：

1. 当前线程拥有其他线程需要的资源
2. 当前线程等待其他线程已拥有的资源
3. 都不放弃自己拥有的资源

如何避免死锁：

1. 产生的原因避免任意一个
2. 由于所施加的限制条件往往太严格，可能会导致系统资源利用率。

"""
模仿死锁现象
"""
from threading import Lock,Thread
from time import sleep

# 账户
class Account:
    def __init__(self,id,balance,lock):
        self.id = id
        self.balance = balance # 存款
        self.lock = lock

# 初始化2个账户
Tom = Account('1',5000,Lock())
Abby = Account('2',4000,Lock())

# 转账
def transfer(f,t,amount):
    """
    :param f:  转出
    :param t:  转入
    :param amount: 金额
    """
    f.lock.acquire() # 自己的锁住
    f.balance -= amount
    f.lock.release()  # 账户解锁   不会产生死锁

    sleep(0.1)
    t.lock.acquire() # 对方的账户锁住
    t.balance += amount

    # f.lock.release() # 账户解锁 会产生死锁
    t.lock.release()

t1 = Thread(target=transfer,args=(Tom,Abby,1500))
t2 = Thread(target=transfer,args=(Abby,Tom,500))
t1.start()
t2.start()
t1.join()
t2.join()

print("Tom:",Tom.balance)
print("Abby:",Abby.balance)