python3 - 多线程 - threading 模块（基于win系统）- Thread、Timer 组件

目录

一、threading 模块：对线程的处理
<https://blog.csdn.net/qq_33961117/article/details/82462745#%E4%B8%80%E3%80%81threading%20%E6%A8%A1%E5%9D%97%EF%BC%9A%E5%AF%B9%E7%BA%BF%E7%A8%8B%E7%9A%84%E5%A4%84%E7%90%86>

二、Thread组件
<https://blog.csdn.net/qq_33961117/article/details/82462745#-%20Thread%E7%BB%84%E4%BB%B6>

2-1 开启线程的方式一（函数）
<https://blog.csdn.net/qq_33961117/article/details/82462745#-%20%E5%BC%80%E5%90%AF%E7%BA%BF%E7%A8%8B%E7%9A%84%E6%96%B9%E5%BC%8F%E4%B8%80%EF%BC%88%E5%87%BD%E6%95%B0%EF%BC%89>

2-2 开启线程的方式二 （类）
<https://blog.csdn.net/qq_33961117/article/details/82462745#-%20%E5%BC%80%E5%90%AF%E7%BA%BF%E7%A8%8B%E7%9A%84%E6%96%B9%E5%BC%8F%E4%BA%8C%20%EF%BC%88%E7%B1%BB%EF%BC%89>

2-3 Thread 相关内置子方法 
<https://blog.csdn.net/qq_33961117/article/details/82462745#-%20Thread%20%E7%9B%B8%E5%85%B3%E5%86%85%E7%BD%AE%E5%AD%90%E6%96%B9%E6%B3%95%C2%A0>

2-4 主进程等待新建线程实例
<https://blog.csdn.net/qq_33961117/article/details/82462745#-%20%E4%B8%BB%E8%BF%9B%E7%A8%8B%E7%AD%89%E5%BE%85%E6%96%B0%E5%BB%BA%E7%BA%BF%E7%A8%8B%E5%AE%9E%E4%BE%8B>

2-5 线程共用创造进程内资源
<https://blog.csdn.net/qq_33961117/article/details/82462745#2-5%20%E7%BA%BF%E7%A8%8B%E5%85%B1%E7%94%A8%E5%88%9B%E9%80%A0%E8%BF%9B%E7%A8%8B%E5%86%85%E8%B5%84%E6%BA%90>

2-7 查看线程和‘父’进程的pid
<https://blog.csdn.net/qq_33961117/article/details/82462745#%C2%A0-%20%E6%9F%A5%E7%9C%8B%E7%BA%BF%E7%A8%8B%E5%92%8C%E2%80%98%E7%88%B6%E2%80%99%E8%BF%9B%E7%A8%8B%E7%9A%84pid>

2-8 Thread 实现 “守护线程”
<https://blog.csdn.net/qq_33961117/article/details/82462745#2-8%20Thread%20%E5%AE%9E%E7%8E%B0%20%E2%80%9C%E5%AE%88%E6%8A%A4%E7%BA%BF%E7%A8%8B%E2%80%9D>

2-8-1 守护线程概念介绍
<https://blog.csdn.net/qq_33961117/article/details/82462745#-%20%E5%AE%88%E6%8A%A4%E7%BA%BF%E7%A8%8B>

2-8-2 实现简单 ‘守护线程’
<https://blog.csdn.net/qq_33961117/article/details/82462745#-%20%E5%AE%9E%E7%8E%B0%E7%AE%80%E5%8D%95%20%E2%80%98%E5%AE%88%E6%8A%A4%E7%BA%BF%E7%A8%8B%E2%80%99>

2-9 Thread + Lock 实现线程“互斥锁” 
<https://blog.csdn.net/qq_33961117/article/details/82462745#2-9%20Thread%20%2B%20Lock%20%E5%AE%9E%E7%8E%B0%E7%BA%BF%E7%A8%8B%E2%80%9C%E4%BA%92%E6%96%A5%E9%94%81%E2%80%9D%C2%A0>

2-10 Thead + Semaphore 实现 “信号量”
<https://blog.csdn.net/qq_33961117/article/details/82462745#%C2%A0-%20Thead%20%2B%20Semaphore%20%E5%AE%9E%E7%8E%B0%20%E2%80%9C%E4%BF%A1%E5%8F%B7%E9%87%8F%E2%80%9D>

2-11 Thread + Event 实现 “事件”
<https://blog.csdn.net/qq_33961117/article/details/82462745#%C2%A0-%20Thread%20%2B%20Event%20%E5%AE%9E%E7%8E%B0%20%E2%80%9C%E4%BA%8B%E4%BB%B6%E2%80%9D>

三、Timer 组件：定时器，n秒后执行操作
<https://blog.csdn.net/qq_33961117/article/details/82462745#-%20Timer%20%E7%BB%84%E4%BB%B6%EF%BC%9A%E5%AE%9A%E6%97%B6%E5%99%A8%EF%BC%8Cn%E7%A7%92%E5%90%8E%E6%89%A7%E8%A1%8C%E6%93%8D%E4%BD%9C>

一、threading 模块：对线程的处理

multiprocess模块的完全模仿了threading模块的接口，二者在使用层面，有很大的相似性；

官方链接 <https://docs.python.org/3/library/threading.html?highlight=threading#>

二、Thread组件

2-1 开启线程的方式一（函数）
from threading import Thread import time def task(name): print('%s is running'
% name) time.sleep(2) print('%s is done' % name) if __name__ == '__main__': t =
Thread(target=task, args=('线程1',)) t.start() print('main')
2-2 开启线程的方式二 （类）
from threading import Thread import time class Mythread(Thread): def
run(self): print('%s is running' % self.name) time.sleep(2) print('%s is done'
% self.name) if __name__ == '__main__': t = Mythread() t.start() print('main')
2-3 Thread 相关内置子方法 

* obj.isAlive():返回线程是否为活动状态
* obj.getName():返回线程名
* obj.setName():设置线程名
* threading.currentThread():返回当前的线程变量
* threading.enumerate():返回一个包含正在运行的线程list，即线程启动后、结束前，不包括启动前和终止后的线程。
* threading.actibeCount():返回正在运行的线程数量，同 len ( threading.enumerate ( ) ) from
threading import Thread import threading from multiprocessing import Process
import os def work(): import time time.sleep(3)
print(threading.current_thread().getName()) if __name__ == '__main__':
#在主进程下开启线程 t=Thread(target=work) t.start()
print(threading.current_thread().getName()) print(threading.current_thread())
#主线程 print(threading.enumerate()) #连同主线程在内有两个运行的线程
print(threading.active_count()) print('主线程/主进程') ''' 打印结果: MainThread
<_MainThread(MainThread, started 140735268892672)> [<_MainThread(MainThread,
started 140735268892672)>, <Thread(Thread-1, started 123145307557888)>] 主线程/主进程
Thread-1 '''
2-4 主进程等待新建线程实例
from threading import Thread import time def sayhi(name): time.sleep(2)
print('%s say hello' %name) if __name__ == '__main__':
t=Thread(target=sayhi,args=('egon',)) t.start() t.join() print('主进程')
print(t.is_alive()) ''' >>>egon say hello >>>主进程 >>>False '''
2-5 线程共用创造进程内资源
from threading import Thread n = 100 def task(): global n n = 0 if __name__ ==
'__main__': t = Thread(target=task) t.start() t.join() print('主', n) ''' >>>主 0
'''
 

2-7 查看线程和‘父’进程的pid
from threading import Thread import os def task(): print('%s is running' %
os.getpid()) if __name__ == '__main__': t = Thread(target=task) t.start()
print('主', os.getpid()) ''' >>>14488 is running >>>主 14488 '''
2-8 Thread 实现 “守护线程”

2-8-1 守护线程概念介绍

守护线程：守护线程会等待主进程内，所有非守护线程，全部运行完毕后，才进行销毁。即，等待进程结束。

2-8-2 实现简单 ‘守护线程’
from threading import Thread import time def foo(): print(123) time.sleep(1)
print("end123") def bar(): print(456) time.sleep(3) print("end456") t1 =
Thread(target=foo) t2 = Thread(target=bar) t1.daemon = True t1.start()
t2.start() print("main-------") ''' >>>123 >>>456 >>>main------- >>>end123
>>>end456 '''
2-9 Thread + Lock 实现线程“互斥锁” 
from threading import Thread, Lock import time mutex = Lock() # 每个线程内创建一把锁 n =
100 def task(): global n # 加锁操作 # mutex.acquire() # temp = n # time.sleep(0.1)
# n = temp - 1 # mutex.release() with mutex: temp = n time.sleep(0.1) n = temp
- 1 if __name__ == '__main__': t_l = [] for i in range(100): t =
Thread(target=task) t_l.append(t) # 添加线程对象 t.start() # 等待每一个线程结束 for t in t_l:
t.join() print(n)
2-10 Thead + Semaphore 实现 “信号量”

* 信号量：保证只有指定数量线程，才能进行连接资源操作。
* Semaphore：内部管理一个计数器，每次调用acquire()时+1，每次release()时-1.保证了每次连接的指定数量。 from
threading import Thread,Semaphore import time,random sm=Semaphore(5)
#设置信号量允许连接数 def task(name): sm.acquire() print('%s 正在使用' %name)
time.sleep(random.randint(1,3)) sm.release() if __name__ == '__main__': for i
in range(20): t=Thread(target=task,args=('路人%s' %i,)) t.start()
2-11 Thread + Event 实现 “事件”

*  事件：设置面向线程的一个信号标志，控制线程的执行
* Event对象
* 包含一个由线程设置的信号标志，允许线程等待事件发生。
* 在初始状态下，信号标志为False。
* 如果存在线程等待Event对象，则Event对象的标志为False，线程将被阻塞至对象标志改变为True。
* 如果一个线程等待一个标志为True的Event对象，那么线程将忽略此事件对象，继续执行。
* Event对象内部方法
* event.isSet():返回event的状态
* event.wait():如果状态值==False，将阻塞线程
* event.set():如果event的状态值为True，所有阻塞池的线程激活进入就绪状态，等待操作系统调度
* event.clear():回复envent的状态为False from threading import Thread,Event import
time event=Event() def light(): print('红灯正亮着') time.sleep(3) event.set() #绿灯亮
def car(name): print('车%s正在等绿灯' %name) event.wait() #等灯绿 print('车%s通行' %name)
if __name__ == '__main__': # 红绿灯 t1=Thread(target=light) t1.start() # 车 for i
in range(10): t=Thread(target=car,args=(i,)) t.start()
三、Timer 组件：定时器，n秒后执行操作
from threading import Timer def hello(): print("hello, world") t = Timer(1,
hello) t.start() # after 1 seconds, "hello, world" will be printed
 

 

• « 上一篇：抽象类能实例化吗？——口气很强硬——“不能”（详解）
• » 下一篇：UTF-16 -- 顶级程序员也会忽略的系统编码问题，JDK 错了十年！