Python代码中创建新线程
python3 将 系统调用创建线程 的功能封装在 标准库 threading 中。
大家来看下面的一段代码
print('主线程执行代码')
from threading import Thread
from time import sleep
def threadFunc(arg1,arg2):
print('子线程 开始')
print(f'线程函数参数是：{arg1}, {arg2}')
sleep(5)
print('子线程 结束')
thread = Thread(
target=threadFunc,
args=('参数1', '参数2')
)
thread.start()
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才继续执行后续的代码。
所以主线程在执行上面的代码时，就暂停在此处， 一直要等到 新线程执行完毕，退出后，才会继续执行后续的代码。
join通常用于 主线程把任务分配给几个子线程，等待子线程完成工作后，需要对他们任务处理结果进行再处理。
就好像一个领导把任务分给几个员工，等几个员工完成工作后，他需要收集他们提交的报告，进行后续处理。
这种情况，主线程必须子线程完成才能进行后续操作，所以join就是 等待参数对应的线程完成，才返回。
共享数据的访问控制
做多线程开发，经常遇到这样的情况：多个线程里面的代码 需要访问 同一个 公共的数据对象。
这个公共的数据对象可以是任何类型， 比如一个 列表、字典、或者自定义类的对象。
有的时候，程序 需要 防止线程的代码 同时操作 公共数据对象。 否则，就有可能导致 数据的访问互相冲突影响。
请看一个例子。
我们用一个简单的程序模拟一个银行系统，用户可以往自己的帐号上存钱。
对应代码如下：
from threading import Thread
from time import sleep
bank = {
'byhy' : 0
}
def deposit(theadidx,amount):
balance = bank['byhy']
sleep(0.1)
bank['byhy'] = balance + amount
print(f'子线程 {theadidx} 结束')
theadlist = []
for idx in range(10):
thread = Thread(target = deposit,
args = (idx,1)
)
thread.start()
theadlist.append(thread)
for thread in theadlist:
thread.join()
print('主线程结束')
print(f'最后我们的账号余额为 {bank["byhy"]}')
上面的代码中，一起执行
开始的时候， 该帐号的余额为0，随后我们启动了10个线程， 每个线程都deposit函数，往帐号byhy上存1元钱。
可以预期，执行完程序后，该帐号的余额应该为 10。
然而，我们运行程序后，发现结果如下
子线程 0 结束
子线程 3 结束
子线程 2 结束
子线程 4 结束
子线程 1 结束
子线程 7 结束
子线程 5 结束
子线程 9 结束
子线程 6 结束
子线程 8 结束
主线程结束
最后我们的账号余额为 1
为什么是 1 呢？ 而不是 10 呢？
如果在我们程序代码中，只有一个线程，如下所示
from time import sleep
bank = {
'byhy' : 0
}
def deposit(theadidx,amount):
balance = bank['byhy']
sleep(0.1)
bank['byhy'] = balance + amount
for idx in range(10):
deposit (idx,1)
print(f'最后我们的账号余额为 {bank["byhy"]}')
代码都是 串行 执行的。 不存在多线程同时访问 bank对象 的问题，运行结果一切都是正常的。
现在我们程序代码中，有多个线程，并且在这个几个线程中都会去调用 deposit，就有可能同时操作这个bank对象，就有可能出一个线程覆盖另外一个线程的结果的问题。
这时，可以使用 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']
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()
theadlist.append(thread)
for thread in theadlist:
thread.join()
print('主线程结束')
print(f'最后我们的账号余额为 {bank["byhy"]}')
执行一下，结果如下
子线程 0 结束
子线程 1 结束
子线程 2 结束
子线程 3 结束
子线程 4 结束
子线程 5 结束
子线程 6 结束
子线程 7 结束
子线程 8 结束
子线程 9 结束
主线程结束
最后我们的账号余额为 10
正确了。
Lock 对象的acquire方法 是申请锁。
每个线程在 操作共享数据对象之前，都应该 申请获取操作权，也就是 调用该 共享数据对象对应的锁对象的acquire方法。
如果线程A 执行如下代码，调用acquire方法的时候，
bankLock.acquire()
别的线程B 已经申请到了这个锁， 并且还没有释放，那么 线程A的代码就在此处 等待 线程B 释放锁，不去执行后面的代码。
直到线程B 执行了锁的 release 方法释放了这个锁， 线程A 才可以获取这个锁，就可以执行下面的代码了。
如果这时线程B 又执行 这个锁的acquire方法， 就需要等待线程A 执行该锁对象的release方法释放锁， 否则也会等待，不去执行后面的代码。
daemon线程
大家执行下面的代码
from threading import Thread
from time import sleep
def threadFunc():
sleep(2)
print('子线程 结束')
thread = Thread(target=threadFunc)
thread.start()
print('主线程结束')
可以发现，主线程先结束，要过个2秒钟，等子线程运行完，整个程序才会结束退出。
因为：
Python程序中当所有的 非daemon线程 结束了，整个程序才会结束
主线程是非daemon线程，启动的子线程缺省也是 非daemon 线程。
所以，要等到 主线程和子线程 都结束，程序才会结束。
我们可以在创建线程的时候，设置daemon参数值为True，如下
from threading import Thread
from time import sleep
def threadFunc():
sleep(2)
print('子线程 结束')
thread = Thread(target=threadFunc,
daemon=True
)
thread.start()
print('主线程结束')
再次运行，可以发现，只要主线程结束了，整个程序就结束了。因为只有主线程是非daemon线程。
多进程
Python 官方解释器 的每个线程要获得执行权限，必须获取一个叫 GIL （全局解释器锁） 的东西。
这就导致了 Python 的多个线程 其实 并不能同时使用 多个CPU核心。
所以如果是计算密集型的任务，不能采用多线程的方式。
大家可以运行一下如下代码
from threading import Thread
def f():
while True:
b = 53*53
if __name__ == '__main__':
plist = []
for i in range(10):
p = Thread(target=f)
p.start()
plist.append(p)
for p in plist:
p.join()
运行后，打开任务管理器，可以发现 即使是启动了10个线程，依然只能占用一个CPU核心的运算能力。
如果需要利用电脑多个CPU核心的运算能力，可以使用Python的多进程库，如下
from multiprocessing import Process
def f():
while True:
b = 53*53
if __name__ == '__main__':
plist = []
for i in range(2):
p = Process(target=f)
p.start()
plist.append(p)
for p in plist:
p.join()
运行后，打开任务管理器，可以发现 有3个Python进程，其中主进程CPU占用率为0，两个子进程CPU各占满了一个核心的运算能力。
仔细看上面的代码，可以发现和多线程的使用方式非常类似。
还有一个问题，主进程如何获取 子进程的 运算结果呢？
可以使用多进程库 里面的 Manage 对象，如下
from multiprocessing import Process,Manager
from time import sleep
def f(taskno,return_dict):
sleep(2)
return_dict[taskno] = taskno
if __name__ == '__main__':
manager = Manager()
return_dict = manager.dict()
plist = []
for i in range(10):
p = Process(target=f, args=(i,return_dict))
p.start()
plist.append(p)
for p in plist:
p.join()
print('get result...')
for k,v in return_dict.items():
print (k,v)
|