python -队列、线程池

队列

python内置一个queue模块，包含四种队列

1. queue.Queue: FIFO
2. queue.LifoQueue: LIFO
3. queue.PriorityQueue: 优先级队列
4. queue.deque: 双向队列

队列的使用场景:

1. 提高并发
2. 流量削峰
3. 程序解耦

基本生产者与消费者的Demo

from Queue import Queue as queue

def func(q):
	# 生产者
    for i in range(0, 10):
        q.put(i)

	# 消费者
    for j in range(0, 10):
        res = q.get(j)
        print(j)
        # 由消费者调用，每一个get()得到一个任务后，由task_done()通知队列此任务已经处理完成
        q.task_done()
    # 阻塞等待
    q.join()

if __name__ == '__main__':
    q = queue()
    func(q)

多线程、队列

import threading
import time
import random
from Queue import Queue as queue

q = queue()

def func_put(index):
    q.put(index)

def func_get(index):
    q.get(index)
    time.sleep(random.randint(1, 4))
    print(index)
    q.task_done()

def producer():
    for i in range(0, 10):
        t = threading.Thread(target = func_put, args = (i, ))
        t.start()

def consumer():
    for i in range(0, 10):
        t = threading.Thread(target = func_get, args = (i, ))
        t.start()

if __name__ == '__main__':
    producer()
    consumer()
    q.join()

执行结果:

python demo-4.py
0
5
8
3
...

基本线程池（多线程+队列模型）

因为在切换线程时需要切换上下文环境，会造成cpu的大量开销，所以在使用多线程处理任务时并不是线程越多越好。为了解决这个问题，提出了线程池的逻辑模型。预先创建好一个较为优化的数量的线程，让过来的任务立刻能够使用，就形成了线程池。

import threading
import time
from Queue import Queue as queue

class MyThread():
    def __init__(self, maxsize = 5):
        self.maxsize = maxsize
        self.q = queue(maxsize)
        for i in range(maxsize):
            self.q.put(threading.Thread)

    def put_thread(self):
        return self.q.put(threading.Thread)

    def get_thread(self):
        return self.q.get()

def task(index, pool):
    time.sleep(1)
    print(index)
    pool.put_thread()

if __name__ == '__main__':
    pool = MyThread(5)
    for i in range(10):
        t = pool.get_thread()
        obj = t(target = task, args = (i, pool, ))
        obj.start()

执行结果:

$ python demo-5.py
0
1
2
...