1.线程管理
使用模块threading使用类Thread,
基础格式:
1.线程的创建:
A.使用threading.Thread(target=methodname,args=())创建对象,传入方法名和需求参数
B.定义类继承Thread类,并改写run()方法,再用自定义类创建对象
2.线程的启动
.start()
3.等待线程结束.join()
join(timeout)参数指占用CPU时间,无参默认为占用至线程结束。join()之后的语句在线程结束后才能执行
代码示例:
####threading模块用于线程控制
####主要流程:
###1.创建线程对象
###2.线程start()
###3.等待线程结束join(timeout ),timeout表示占用CPU的时间,无参默认为占用至线程结束。
###join()的作用是等该线程运行完之后才执行join之后的内容,可以认为控制线程的顺序
###4.
threads=[]
import threading
import time
def printId(Id):
print("线程%d执行中..."%(Id))
time.sleep(1)
print("线程%d执行结束..."%(Id))
###1.创建线程对象
###两种方法:1.用threading.Thread(target=methodname,args=(arg1,arg2,...))构造函数创建
###########2.继承Thread类,并复写其run()方法,对象start()后会自动调用run()方法执行
###########传入的方法只能是方法名,不能带括号
for i in range(5):
threads.append(threading.Thread(target=printId,args=(i,)))
###1.1用继承类的方式创建线程
class MyThread(threading.Thread):
def __init__(self,id):
super(MyThread, self).__init__()
self.id=id
def run(self):
print("线程%d开始执行"%(self.id))
my_thread = MyThread(6)
##2.线程的start()
##3.线程的join()
threads[0].start()
threads[0].join()
threads[1].start()
threads[1].join()
threads[2].start()
threads[2].join()
threads[3].start()
threads[3].join()
threads[4].start()
threads[4].join()
my_thread.start()
my_thread.join()
演示结果:
线程0执行中...
线程0执行结束...
线程1执行中...
线程1执行结束...
线程2执行中...
线程2执行结束...
线程3执行中...
线程3执行结束...
线程4执行中...
线程4执行结束...
线程6开始执行
2.队列的使用
队列对象导入queue模块,使用queue.Queue()的方式创建,具有先入先出的特性,可以方便线程的同步管理。
queue.get()获取头部
queue.put(obj)放入尾部
代码示例:
import threading
import time
import queue
#创建工作队员组
work_queue=queue.Queue(maxsize=10)
#创建结果接收组
result_queue=queue.Queue(maxsize=10)
class WorkerThread(threading.Thread):
def __init__(self,id):
super(WorkerThread, self).__init__()
self.id=id
def run(self):
while not work_queue.empty():
work=work_queue.get()
time.sleep(1)
out="Thread %d\t received %d"%(self.id,work)
result_queue.put(out)
def main():
for i in range(10):
work_queue.put(i)
for i in range(2):
thread=WorkerThread(i)
thread.start()
for i in range(10):
print(result_queue.get())
if __name__=="__main__":
main()
演示结果:
Thread 0 received 0
Thread 1 received 1
Thread 1 received 3
Thread 0 received 2
Thread 0 received 5
Thread 1 received 4
Thread 1 received 7
Thread 0 received 6
Thread 1 received 8
Thread 0 received 9
3.线程池
模块:mutiprocessing.dummy
使用类:Pool
创建方法:Pool(processes=int)线程池容量
使用方法:
1.请求线程:pool.apply_async(methodname,args=())(含义同Thread的创建)
2.关闭线程池:pool.close()
3.等待线程池:pool.join()
代码演示:
######线程池
####1.线程池的创建
####2.线程池请求线程
####3.线程池的关闭
import time
import multiprocessing.dummy
def process_func(process_id):
print("process id %d start"%(process_id))
time.sleep(3)
print("process id %d end"%(process_id))
def main():
#创建容量为3的进程池
pool = multiprocessing.dummy.Pool(processes=3)
for i in range(10):
#向线程池中请求线程
pool.apply_async(process_func,args=(i,))
pool.close()#关闭线程池
pool.join()
if __name__=="__main__":
main()
演示结果:
可以看见当请求超出容量后,老进程关闭后,新进程才会开始
process id 0 start
process id 1 start
process id 2 start
process id 2 end
process id 3 start
process id 1 endprocess id 0 end
process id 4 start
process id 5 start
process id 5 end
process id 6 start
process id 4 endprocess id 3 end
process id 7 start
process id 8 start
process id 7 endprocess id 6 end
process id 8 end
process id 9 start
process id 9 end