Python学习笔记10——多线程

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