通过重写run调用线程:
import threading
def handle(sid):
print("Thread %d run"%sid,threading.current_thread())
class MyThread(threading.Thread):
def __init__(self,sid):
threading.Thread.__init__(self)
self.sid=sid
def run(self):
handle(self.sid)
for i in range(1,11):
t=MyThread(i)
t.start()
t.join()
线程同步之信号量控制实现:
semaphore=threading.Semaphore(0)#先生产再消费,item默认初值可以不用设置
semaphore=threading.BoundedSemaphore(1)#先消费再生产,再消费。item必须要有默认初值
通过acquire锁住线程,通过release解锁线程。
import threading
import time
import random
# semaphore=threading.Semaphore(0)#先生产再消费,item默认初值可以不用设置
semaphore=threading.BoundedSemaphore(1)#先消费再生产,再消费。item必须要有默认初值
def consumer():
print("挂起:")
semaphore.acquire()
print("Consumer:消费%s."%item)
def producer():
global item
item=1000
time.sleep(1)
item=random.randint(1,1000)
print("producer:生产%s."%item)
semaphore.release()
threads=[]
for i in range(0,2):
t2=threading.Thread(target=consumer)
t1=threading.Thread(target=producer)
t1.start()
t2.start()
threads.append(t1)
threads.append(t1)
for t in threads:
t.join()
线程同步之事件机制实现:
import queue
通过queue.Queue()的wait、set、clear实现
import queue
from random import randint
from threading import Thread
from threading import Event
class WriteThread(Thread):
def __init__(self,q,WE,RE):
super().__init__()
self.queue=q
self.RE=RE
self.WE=WE
def run(self):
data=[randint(1,10) for _ in range(0,5)]
self.queue.put(data)
print("WT,写入RT完毕{0}".format(data))
self.RE.set()
print("WT,通知RT线程")
self.WE.wait()
print("WT,写入事件完毕")
self.WE.clear()
print("WT,清理完毕")
class ReadThread(Thread):
def __init__(self,q,WE,RE):
super().__init__()
self.queue=q
self.RE=RE
self.WE=WE
def run(self):
while True:
self.RE.wait()
print("RT,读取等待")
data=self.queue.get()
print("RT,读取WE数据{0}".format(data))
self.WE.set()
print("RT,发送写事件")
self.RE.clear()
print("RT,清理完毕")
q=queue.Queue()
WE=Event()
RE=Event()
writethread=WriteThread(q,WE,RE)
readthread=ReadThread(q,WE,RE)
writethread.start()
readthread.start()
线程同步之条件锁实现:
from threading import Condition
c=Condition
通过c.acquire()锁住资源,c.release()释放资源
from threading import Thread
from threading import Condition
import time
import random
c=Condition()
itemNum=0
item=0
def consumer():
global item
global itemNum
c.acquire()#锁住资源
while 0==itemNum:
print("Consumer:挂起")
c.wait()#等待
itemNum-=1
print("Consumer:消费%s"%item,itemNum)
c.release()#释放资源
def producer():
global item
global itemNum
time.sleep(1)
c.acquire()
item=random.randint(1,1000)
itemNum+=1
print("Producer:生产%s"%item)
c.notifyAll()#唤起所有线程,放置线程永远处理沉默状态
# c.notify()#换起被wait挂起的线程
c.release()
threads=[]
for i in range(0,3):
t1=Thread(target=producer)
t2=Thread(target=consumer)
t1.start()
t2.start()
threads.append(t1)
threads.append(t2)
for t in threads:
t.join()#等待所有线程完成
通过定时器实现轮动(持续打印):
threading.Timer(1,func)
import threading
import time
def loop_timer_headle():
print('Timer Headle!')
global timer2
timer2=threading.Timer(1,loop_timer_headle)#创建定时器
timer2.start()
timer2=threading.Timer(1,loop_timer_headle)#创建定时器
timer2.start()
time.sleep(10)
timer2.cancel()#结束定时器
通过submit和map分别实现抢占线程池和非抢占线程池:
from concurrent.futures import ThreadPoolExecutor
import time
def printperson(p):
print(p)
time.sleep(1)
person=['Student','Teacher','Monther','Father','Son']
#创建抢占线程池
start1=time.time()
with ThreadPoolExecutor(len(person)) as executor:
for i in person:
executor.submit(printperson,i)
end1=time.time()
print("time1:"+str(end1-start1))
#非抢占线程池
start2=time.time()
with ThreadPoolExecutor(len(person)) as executor:
executor.map(printperson,person)
end2=time.time()
print("time2:"+str(end2-start2))