python threading模块中的timer_python3 - 多线程 - threading 模块（基于win系统）- Thread、Timer 组件...

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

发布时间：2018-09-06 16:26,

浏览次数：194

, 标签：

python

threading

win

Thread

Timer

目录

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

二、Thread组件

2-1 开启线程的方式一(函数)

2-2 开启线程的方式二 (类)

2-3 Thread 相关内置子方法

2-4 主进程等待新建线程实例

2-5 线程共用创造进程内资源

2-7 查看线程和‘父’进程的pid

2-8 Thread 实现 “守护线程”

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

2-8-2 实现简单 ‘守护线程’

2-9 Thread + Lock 实现线程“互斥锁”

2-10 Thead + Semaphore 实现 “信号量”

2-11 Thread + Event 实现 “事件”

三、Timer 组件：定时器，n秒后执行操作

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

multiprocess模块的完全模仿了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 started> [<_mainthread>

started 140735268892672)>, ] 主线程/主进程

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