多线程和多进程

• 如下程序，运行起来后，只有一个线程，就是主线程，在主线程里面，执行代码，顺序下来，一直执行到结束， 主线程就退出了。 同时进程也结束了。

fee = input('请输入午餐费用：')
members = input('请输入聚餐人姓名，以英文逗号,分隔：')
 
# 将人员放入一个列表
memberlist = members.split(',') 
# 得到人数
headcount = len(memberlist) 
 
# 计算人均费用
avgfee = int (fee) / headcount
print(avgfee)

• 创建新线程，如果没有执行join方法，主线程不会等待子线程

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 参数 指定 新线程要执行的函数
    # 注意，这里指定的函数对象只能写一个名字，不能后面加括号，
    # 如果加括号就是直接在当前线程调用执行，而不是在新线程中执行了
    target=threadFunc, 
 
    # 如果 新线程函数需要参数，在 args里面填入参数
    # 注意参数是元组， 如果只有一个参数，后面要有逗号，像这样 args=('参数1',)
    args=('参数1', '参数2')
)
 
# 执行start 方法，就会创建新线程，
# 并且新线程会去执行入口函数里面的代码。
# 这时候 这个进程 有两个线程了。
thread.start()
 
# 主线程的代码执行 子线程对象的join方法，
# 就会等待子线程结束，才继续执行下面的代码
thread.join()
print('主线程结束')

• 共享数据访问控制，即加锁

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"]}')

• Python程序中当所有的 非daemon线程 结束了，整个程序才会结束
• 只要主线程结束了，整个程序就结束了。因为只有主线程是非daemon线程。

from threading import Thread
from time import sleep
 
def threadFunc():
    sleep(2)
    print('子线程 结束')
 
thread = Thread(target=threadFunc,
                daemon=True # 设置新线程为daemon线程
                )
thread.start()
print('主线程结束')

• 多进程

from multiprocessing import Process
 
def f():
    while True:
        b = 53*53
 
if __name__ == '__main__':
    plist = []
    for i in range(2):  # 启动2个线程
        p = Process(target=f)
        p.start()
        plist.append(p)
 
    for p in plist:
        p.join()

• 主进程获取子进程的运算结果

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)