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

import threading
import math
import datetime

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

# 直接继承线程类，然后覆盖继承类函数的方法
class ThreadChild(threading.Thread):
    # 初始化 init: 通常继承线程类会扩写父类的初始化，来传递参数等。
    def __init__(self, num_list, name, ret_dic, ret_lock):
        # 扩写父类的初始化，首先调用父类的初始化
        threading.Thread.__init__(self)
        self.num_list = num_list
        self.name = name
        self.ret_dic = ret_dic
        self.ret_lock = ret_lock
        return

    # 运行 run: 这是一个必须要覆盖的函数。启动线程调用的 start() 函数就是运行这个函数，这里是需要运行的核心代码。
    def run(self):# 覆盖重写函数 run
        result = 0
        for num in self.num_list:
            result += math.sqrt(num * math.tanh(num) / math.log2(num) / math.log10(num))
        self.ret_lock.acquire()# 锁住, 锁住之后的代码将只能被一个线程执行下去，直到开锁
        self.ret_dic[self.name] = result
        self.ret_lock.release()# 开锁, 开锁之后，被锁住的资源和代码行又可以重新被其他线程读写
        return


if __name__ == '__main__':

    thread_pool = []
    ret_dic = {}
    # 锁类 Lock: 在线程中需要读写一个共享资源的时候，通过锁类来锁住资源，防止另外的线程读写修改。
    ret_lock = threading.Lock()

    # 多线程
    th_1 = ThreadChild(num_list=list(range(10, 3000000)), name='th_1', ret_dic=ret_dic, ret_lock=ret_lock)
    th_2 = ThreadChild(num_list=list(range(3000000, 6000000)), name='th_2', ret_dic=ret_dic, ret_lock=ret_lock)
    th_3 = ThreadChild(num_list=list(range(6000000, 9000000)), name='th_3', ret_dic=ret_dic, ret_lock=ret_lock)
    thread_pool.append(th_1)
    thread_pool.append(th_2)
    thread_pool.append(th_3)

    start_t = datetime.datetime.now()

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

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

    final_result = sum(ret_dic.values())
    end_t = datetime.datetime.now()
    elapsed_sec = (end_t - start_t).total_seconds()
    print("多线程计算结果: " + "{:.1f}".format(final_result) + ", 共消耗: " + "{:.2f}".format(elapsed_sec) + " 秒")

    # 单线程
    ret_dic.clear()
    th_4 = ThreadChild(num_list=list(range(10, 9000000)), name='th_4', ret_dic=ret_dic, ret_lock=ret_lock)
    start_t = datetime.datetime.now()
    th_4.start()# 非阻塞 start()
    th_4.join()# 阻塞 join()
    final_result = sum(ret_dic.values())
    end_t = datetime.datetime.now()
    elapsed_sec = (end_t - start_t).total_seconds()
    print("单线程计算结果: " + "{:.1f}".format(final_result) + ", 共消耗: " + "{:.2f}".format(elapsed_sec) + " 秒")

    # 多线程计算结果: 1484922580.2, 共消耗: 8.72 秒
    # 单线程计算结果: 1484922580.2, 共消耗: 4.03 秒

    # 把这两行注释掉
    # th_3 = ThreadChild(num_list=list(range(6000000, 9000000)), name='th_3', ret_dic=ret_dic, ret_lock=ret_lock)
    # thread_pool.append(th_3)
    # 多线程计算结果: 830326785.5, 共消耗: 3.01 秒
    # 单线程计算结果: 1484922580.2, 共消耗: 4.21 秒

    # 多线程本质上还是在一个进程里做的资源分配优化，还没有利用到多进程，多核心计算的能力。
    # 但是多线程的巨大优势是在遇到阻塞型函数，例如 API 调用，网络通信，文件读写的时候，
    # 可以不被网络速度，硬盘速度耽误了程序其他部分的运算。

    # 以上 Python 的多线程模块来实现计算提速，但是受限于在一个进程，也就是单核心上的运算