# !/usr/bin/env python3
# encoding: utf-8
import time
import threading
def fun(name: str, did: int):
name= threading.current_thread().getName()
print('当前线程名称' + name)
print(f"fun {time.time()}")
# 使用Thread(target=方法名，args=（参数1，参数2）)
t1= threading.Thread(target=fun, args=("name1", 1))
# 可以使用setName 为线程创建名字（必须放在start前面）
t1.setName("test01")
# 守护线程 setDaemon（必须放在start前面）
t1.setDaemon(False) # 不设置为守护线程，主程序要等待子进程执行完毕后才会结束(默认)
t1.setDaemon(True) # 设置为守护线程，主程序执行完毕后子线程也自动关闭
# 使用start 启动线程
t1.start()
# 主线程执行到join进入等待，等待m子线程结束后，主线程才能继续执行
t1.join()
线程类写法
如果觉得直接创建一个线程类，可以直接集成Thread重写它的run方法
"""线程类写法1"""
class MyThread(threading.Thread):
def __init__(self, name, did: str):
threading.Thread.__init__(self)
self.name= name
self.did= did
def run(self):
print(self.name+ " " + self.did)
mt= MyThread("名字", "1")
threading.Lock() 会创建一个线程锁
import threading
lock_object= threading.Lock() # 创建一个锁（这个锁是一个单例）不同线程要用同一把锁才有效）
# 上锁类型一般为安全线程类型
def run_fun():
lock_object.acquire() # 上锁（未解锁其他其他线程得等待这把锁解开才能去拿）
print("内容")
lock_object.release() # 释放这个锁
t2= threading.Thread(target=run_fun)
t3= threading.Thread(target=run_fun
t2.start()
t2.start()
可以使用with 关键字，会自动上锁解锁，减少代码冗余
"""使用with lock_object 会自动帮你加上锁（acquire）和释放锁（release）"""
lock_object2= threading.Lock()
def run_fun1():
with lock_object2:
print("执行内容")
t4= threading.Thread(target=run_fun)
t5= threading.Thread(target=run_fun)
t4.start()
t5.start()
RLock 锁与Lock锁原理相同，不同的是Look锁无法嵌套
"""RLock 锁的优势，不容易变为死锁"""
rlock_object= threading.RLock()
lock_object= threading.Lock()
def run_fun1():
lock_object.acquire() # 使用lock的时候不能连续上锁，否则会直接死锁，导致整个该锁的线程直接阻塞
lock_object.acquire()
print("内容")
lock_object.release() # 释放这个锁
def run_fun2():
rlock_object.acquire() # 使用Rlock的时候可以嵌套锁，不会导致死锁（多线程使用这个函数的话，建议使用Rlock）
rlock_object.acquire()
rlock_object.acquire()
print("内容")
rlock_object.release() # 释放这个锁
线程池的简单使用
使用线程池需要从 concurrent.futures 中导入 ThreadPoolExecutor 模块（python3.7以上才支持线程池的使用）
"""线程池"""
from concurrent.futures import ThreadPoolExecutor
def run_fun(my_name):
print("name is :" + my_name)
name_list= ["name1", "name2", "name3"]
pool= ThreadPoolExecutor(10) # 创建一个线程池对象，最多包含十个线程被维护
for namein name_list:
# pool.submit(方法名1, 参数1，参数2)
pool.submit(run_fun, name) # 会一次性将所有的任务提交给线程池，让线程池去自动分配给自己的线程
pool.shutdown(True) # 出现shutdown 主线程会停下来等待，直到线程池执行结束后才会继续往下走（类似于线程中的join ）
print("主线程结束后，会等待上面线程池执行完毕才会完全结束")
object = pool.submit() 方法 会返回一个对象，类似任务
使用object.add_done_callback(方法名)方法可以指定该线程执行后调用制定方法
"""线程池 add_done_callback 方法"""
from concurrent.futuresimport ThreadPoolExecutor
pool= ThreadPoolExecutor(10)
def test_fun1(number):
return number
def test_fun2(response):
print(f"线程结束后执行{response.result()}")
for iin range(10):
future= pool.submit(test_fun1, i) # 将任务分配给线程池（返回类似于线程id的对象）
future.add_done_callback(test_fun2) # 从返回的对象中得到返回值，使用add_done_callback方法传入后置方法
