目录
扫描二维码关注公众号，回复：
3190372 查看本文章
- Semaphore：内部管理一个计数器，每次调用acquire()时+1，每次release()时-1.保证了每次连接的指定数量。
threading 模块：对线程的处理
- Thread组件
- 开启线程的方式一（函数）
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')
- 开启线程的方式二 （类）
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')- 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
'''- 主进程等待新建线程实例
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
'''- 线程共用创造进程内资源
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
- 查看线程和‘父’进程的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
-Thread 实现 “守护线程”
- 守护线程
守护线程：守护线程会等待主进程内，所有非守护线程，全部运行完毕后，才进行销毁。即，等待进程结束。
- 实现简单 ‘守护线程’
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
- 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)- 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()
- 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