import time,threading

print(“主线程执行代码”)

def threadFunc(arg1, arg2):

print(“子线程开始”)

print(f’参数为：{arg1},{arg2}’)

time.sleep(1)

print(threading.current_thread().name) #threading.current_thread().name 返回当前线程的名字

print(“子线程结束”)

#thread = Thread(target=threadFunc(‘参数1’, ‘参数2’))这样写相当于主线程执行threadFunc()函数，不是创建子线程

thread = threading.Thread(target=threadFunc, args=(1, 2))

thread.start() #开始子线程

thread.join() #等待子线程结束

print(“主线程结束”)

print(threading.current_thread().name)

#多线程访问共享数据

#现在我们程序代码中，有多个线程，并且在这个几个线程中都会去调用 deposit，就有可能同时操作这个bank对象，就有可能出一个线程覆盖另外一个线程的结果的问题。

bank = {‘byhy’: 0}

bankLock = threading.Lock() #threading库中的Lock()方法经行保护

def deposit(threadidx, amount):

bankLock.acquire() #Lock对象的acquire()方法申请锁

balance = bank[‘byhy’]

time.sleep(0.1)

bank[‘byhy’] = balance + amount

print(f’子线程{threadidx}结束’)

bankLock.release() #Lock对象的release()方法释放锁

threadlist = []

for idx in range(10):

thread = threading.Thread(target=deposit, args=(idx, 1))

thread.start()

threadlist.append(thread)

for thread in threadlist:

thread.join()

print(“主线程结束”)

print(f’账户余额为{bank[“byhy”]}’)

#守护(daemon)线程

def treadFunc():

time.sleep(2)

print(“子线程结束”)

#主线程是非daemon线程，子线程也是 非daemon线程 线程。默认为daemon=False

#守护线程是指在程序运行的时候在后台提供一种通用服务的线程，并且这种线程并不属于程序中不可或缺的部分。当所有的非守护线程结束时，程序也就终止了，同时会杀死进程中的所有守护线程

thread = threading.Thread(target=treadFunc, daemon=True)

thread. start()

print(“主线程结束”)

#Python 官方解释器 的每个线程要获得执行权限，必须获取一个叫 GIL （全局解释器锁） 的东西。

#这就导致了 Python 的多个线程 其实 并不能同时使用 多个CPU核心。

#所以如果是计算密集型的任务，不能采用多线程的方式

#如下代码，运行后，打开任务管理器，可以发现 即使是启动了10个线程，依然只能占用一个CPU核心的运算能力。

def f():

while True:

b = 53*53

if name == ‘main’:

plist = []

# 启动10个线程

for i in range(10):

p = threading.Thread(target=f)

p.start()

plist.append§

for p in plist:

p.join()

#多进程

import multiprocessing

def f():

while True:

b = 53*53

if name == ‘main’:

plist = []

for i in range(2):

p = multiprocessing.Process(target=f)

p.start()

plist.append§

for p in plist:

p.join()

#多进程获取子进程运算结果
import multiprocessing, time
def f(return_dict, taskno):
time.sleep(1)
return_dict[taskno] = taskno

if name == “main”:
manager = multiprocessing.Manager()
# 创建 类似字典的 跨进程 共享对象
return_dict = manager.dict()

plist = []
for i in range(10):
    p = multiprocessing.Process(target=f, args=(return_dict, i))
    p.start()
    plist.append(p)

for p in plist:
    p.join()

print("get result...")
for k, v in return_dict.items():
    print(k, v)