python多线程示例2，加锁（仅仅作为记录）

import threading

# 多线程本质上是在一个 Python 程序里做的一个资源再分配，把几段代码的运行顺序进行先后调整达到 CPU 资源利用的最大化。
# 但是这么做的一个缺点就是资源竞争Resource Contention，意思就是有可能几段代码同时在读写一个参数的时候，把这个参数的数值搞混。
# 所以在多线程共享资源的情况下，需要在共享资源外部添加锁 Lock。

# 直接继承线程类，然后覆盖继承类函数的方法
class ThreadChild(threading.Thread):
    # 初始化 init: 通常继承线程类会扩写父类的初始化，来传递参数等。
    def __init__(self, times, name, ret_dic, ret_lock):
        # 扩写父类的初始化，首先调用父类的初始化
        threading.Thread.__init__(self)
        self.times = times
        self.name = name
        self.ret_dic = ret_dic
        self.ret_lock = ret_lock
        return
    # 运行 run: 这是一个必须要覆盖的函数。启动线程调用的 start() 函数就是运行这个函数，这里是需要运行的核心代码。
    def run(self):
        # 覆盖重写函数 run
        for i in range(self.times):
            print(self.name + ' run: ' + str(i))
        self.ret_lock.acquire()# 锁住, 锁住之后的代码将只能被一个线程执行下去，直到开锁
        # 进入有可能竞争的共享资源，锁住
        self.ret_dic[self.name] = self.name + " finished with " + str(self.times) + " times printed"
        # 共享资源读写结束，开锁
        self.ret_lock.release()# 开锁, 开锁之后，被锁住的资源和代码行又可以重新被其他线程读写
        return

if __name__ == '__main__':

    thread_pool = []
    ret_dic = {}
    # 锁类 Lock: 在线程中需要读写一个共享资源的时候，通过锁类来锁住资源，防止另外的线程读写修改。
    # 这里在主程序中创建了一个锁 ret_lock, 并且传入了两个线程中。
    # 这个锁本身是可以在多个线程中共享的，因为锁本身不存在资源竞争的问题，否则就没有意义了。
    ret_lock = threading.Lock()
    th_1 = ThreadChild(times=3, name='th_1', ret_dic=ret_dic, ret_lock=ret_lock)
    th_2 = ThreadChild(times=5, name='th_2', ret_dic=ret_dic, ret_lock=ret_lock)
    thread_pool.append(th_1)
    thread_pool.append(th_2)

    # 非阻塞 start()
    for th in thread_pool:
        th.start()

    # 阻塞 join()
    for th in thread_pool:
        th.join()

    print(ret_dic)

    # 锁类 Lock: 在线程中需要读写一个共享资源的时候，通过锁类来锁住资源，防止另外的线程读写修改。
    #           这里在主程序中创建了一个锁 ret_lock, 并且传入了两个线程中。
    #           这个锁本身是可以在多个线程中共享的，因为锁本身不存在资源竞争的问题，否则就没有意义了。
    # 锁住 Acquire: Acquire() 是锁的一个函数，表示获得资源，也可以表示锁住资源。在这个函数之后的代码将只能被一个线程执行下去，直到开锁。
    # 开锁 Release: Release() 是锁的一个函数，表示释放资源，也可以表示开锁。开锁之后，被锁住的资源和代码行又可以重新被其他线程读写，运行。

    # 全局变量也是 Python 程序的共享资源，在多线程运算中，接触到全局变量的地方都需要加锁，或者也可以直接把锁变成全局变量:
    # import threading
    # glob_lock = threading.Lock()
    # glob_a = 100
    # def increase_by_a(num): # 不好的例子，虽然对全局变量加了锁，但是在函数内部运用了全局变量
    #     glob_lock.acquire()
    #     result = glob_a + num
    #     glob_lock.release()
    #     return result
    # if __name__ == '__main__':
    #     print(increase_by_a(100)) # 返回 200
    #
    #     glob_lock.acquire()
    #     glob_a += 1
    #     glob_lock.release()
    #
    #     print(increase_by_a(100)) # 返回 201，glob_a的改变破坏了函数 increase_by_a 的一致性
    # 这里的锁是在全局变量中的，并且锁住了一个全局变量。
    # 但是我们会发现，两次调用 increase_by_a 函数的过程中，
    # 返回数值因为一个全局变量而变化了，尽管在函数传入的参数是一致的，这就破坏了函数的一致性：
    #     函数的一致性：每次在同一个函数传入相同的参数，返回相同的结果
    # 因此，尽量在函数中避免调用全局变量，或全局锁，以防破坏函数的一致性。