python3多线程-线程同步

1、介绍
多线程同时访问和操作同一资源，可能会造成异常。
解决办法是对资源进行限制，同一时间只允许一个线程进行访问和操作。
这里的资源，一般是指方法、函数或者代码块。即由多行代码组成，在逻辑上属于不可切分的操作。

2、线程同步
使用 Thread 对象的 Lock 和 Rlock 可以实现简单的线程同步，这两个对象都有 acquire 方法和 release 方法，对于那些需要每次只允许一个线程操作的数据，可以将其操作放到 acquire 和 release 方法之间

3、Lock类
（1）类

class Lock:
    def __init__(self) -> None:

（2）初始化

lock = threading.Lock()

（3）方法

# 上锁，对python系统资源独占，当该锁释放，其他线程才可以竞争
lock.acquire()
# 释放
lock.release()
# 判断是否上锁
def locked(self) -> bool
``

4、使用示例
如果不是考虑效率，而是为了并发的效果。一般，会搭配time.sleep函数，使每个线程在结束核心任务后，进行等待状态，让其他线程竞争执行。
如果存在多个线程使用同一资源，需要对各线程中涉及到该资源的代码进行上锁和释放处理，线程等待需要写在释放后才有预期的效果。
```python
import threading
import time

lock = threading.Lock()


def run():
    arr = []
    t = threading.Thread(target=a, args=["zs", 10, arr])
    t1 = threading.Thread(target=p, args=[arr])
    t1.start()
    t.start()

    t.join()
    t1.join()


# 输出结果数组
def p(result: list):
    while True:
        lock.acquire()
        print(len(result))
        lock.release()
        time.sleep(4)


def a(name, count, result: list):
    for i in range(count):
        lock.acquire()
        print("正在添加", name + ":" + str(i))
        result.append(name + ":" + str(i))
        lock.release()
        time.sleep(3)


run()

5、使用示例2
lock锁的使用：
线程内部，只有对共享的资源操作代码进行上锁和释放锁才有意义，对非共享的资源操作代码上锁是无意义的，反而降低了多线程的效率
不同线程间，只有使用的同一个锁对象，才会实现对某共享资源的同步操作。
各线程内执行到调用lock对象的acquire()方法时，判断锁是否被释放状态。如果是释放状态，则上锁，并继续执行。如果是锁定状态，则休眠至其他线程将锁打开。

import threading
import time


class stu:
    # 同步有效，交替执行
    lock = threading.Lock()

    def __init__(self, name):
        self.name = name
        self.id = 0
        # 同步无效，各自执行，混乱
        # self.lock = threading.Lock()

    def p(self, delay):
        while self.id < 30:
            self.lock.acquire()
            print(self.name, self.id)
            self.id = self.id + 1
            time.sleep(delay)
            self.lock.release()


stu1 = stu("a")
t1 = threading.Thread(target=stu1.p, args=[2.5])
t1.start()
stu2 = stu("b")
t2 = threading.Thread(target=stu2.p, args=[2.5])
t2.start()