多线程编程初始

使用多线程编码会使得代码的执行的耗时更少，更充分地利用CPU的性能。以下代码是一个示范，显示如何创建多线程。转自白夜黑羽大佬。

print('主线程执行代码') 

# 从 threading 库中导入Thread类
from threading import Thread
from time import sleep

# 定义一个函数，作为新线程执行的入口函数
def threadFunc(arg1,arg2):
    print('子线程 开始')
    print(f'线程函数参数是：{arg1}, {arg2}')
    sleep(5)
    print('子线程 结束')


# 创建 Thread 类的实例对象， 并且指定新线程的入口函数
thread = Thread(target=threadFunc,
                args=('参数1', '参数2')
                )

# 执行start 方法，就会创建新线程，
# 并且新线程会去执行入口函数里面的代码。
# 这时候 这个进程 有两个线程了。
thread.start()

# 主线程的代码执行 子线程对象的join方法，
# 就会等待子线程结束，才继续执行下面的代码
thread.join()
print('主线程结束')

运行该程序，解释器执行到下面代码时

thread = Thread(target=threadFunc,
args=(‘参数1’, ‘参数2’)
)
创建了一个Thread实例对象，其中，Thread类的初始化参数 有两个

target参数 是指定新线程的 入口函数， 新线程创建后就会 执行该入口函数里面的代码，

args 指定了 传给 入口函数threadFunc 的参数。 线程入口函数 参数，必须放在一个元组里面，里面的元素依次作为入口函数的参数。

注意，上面的代码只是创建了一个Thread实例对象， 但这时，新的线程还没有创建。

要创建线程，必须要调用 Thread 实例对象的 start方法 。也就是执行完下面代码的时候

thread.start()
新的线程才创建成功，并开始执行 入口函数threadFunc 里面的代码。

有的时候， 一个线程需要等待其它的线程结束，比如需要根据其他线程运行结束后的结果进行处理。

这时可以使用 Thread对象的 join 方法

thread.join()
如果一个线程A的代码调用了 对应线程B的Thread对象的 join 方法，线程A就会停止继续执行代码，等待线程B结束。 线程B结束后，线程A才继续执行后续的代码。

所以主线程在执行上面的代码时，就暂停在此处， 一直要等到 新线程执行完毕，退出后，才会继续执行后续的代码。

有时候多个线程需要用到同一个参数，则会就有可能同时操作这个对象，就有可能出一个线程覆盖另外一个线程的结果的问题。

这时，可以使用 threading库里面的锁对象 Lock 去保护。示范如下：

from threading import Thread,Lock
from time import sleep

bank = {
    'byhy' : 0
}

bankLock = Lock()

# 定义一个函数，作为新线程执行的入口函数
def deposit(theadidx,amount):
    # 操作共享数据前，申请获取锁
    bankLock.acquire()
    
    balance =  bank['byhy']
    # 执行一些任务，耗费了0.1秒
    sleep(0.1)
    bank['byhy']  = balance + amount
    print(f'子线程 {theadidx} 结束')
    
    # 操作完共享数据后，申请释放锁
    bankLock.release()

theadlist = []
for idx in range(10):
    thread = Thread(target = deposit,
                    args = (idx,1)
                    )
    thread.start()
    # 把线程对象都存储到 threadlist中
    theadlist.append(thread)

for thread in theadlist:
    thread.join()

print('主线程结束')
print(f'最后我们的账号余额为 {bank["byhy"]}')

这样结果就会正确了。