Python进阶【第二篇】多线程、消息队列queue

1.Python多线程、多进程

目的提高并发
1.一个应用程序，可以有多进程和多线程
2.默认：单进程，单线程
3.单进程，多线程
　　IO操作，不占用CPU
　　python的多线程：IO操作，多线程提供并发
计算性操作
多进程提高并发
4.GIL，全局解释器锁
总结：
多进程，多线程，提供并发
IO密集型：多线程
计算密集型：多进程

2.threading模块

threading模块对象	描述
Thread	表示一个线程的执行的对象
Lock	锁原语对象
RLock	可重入锁对象。使单线程可以再次获得已经获得了的锁(递归锁定)
Event	通用的条件变量。多个线程可以等待某个事件的发生，在事件发生后，所有的线程都会被激活
BoundedSemaphore	每次允许几个线程通过
Timer	等待多久在开始运行

3.如何创建一个线程

#!/usr/bin/env python
# _*_ coding:utf-8 _*_
# 1.先导出threading模块
import threading
import time

def f1(arg):
    time.sleep(2)
    print(arg)

for i in range(10):
    # 2.创建一个线程对象
    t = threading.Thread(target=f1,args=(i,))
    # 创建一个线程那你想让它执行那些操作呢，就是target指定
    # 假设上面的f1是一个函数，那么如果函数可以传参数就用args=(参数1，参数2)
    t.start()
    # t.start()
    # 并不代表当前线程会被立即执行
    # setDaemon方法，主进程执行完就退出不在等待子进程结束
    # t.setDaemon(True)

# 表示主线程到此等待，直到子线程执行完毕
t.join()
print("end")
# 默认情况下主线程不会等待子线程t.start()执行完，而是直接执行下面的print("end"),但是程序不会退出，而是等子进程执行结束后才退出程序

4.定时器Timer()

#!/usr/bin/env python
# _*_ coding:utf-8 _*_
from threading import Timer

def func():
    print("hello world")

# 等1秒钟在执行func函数
t = Timer(1,func)
t.start()

5.消息队列queue模块

queue模块函数	描述
queue（size)	创建一个大小为size的queue对象
queue对象函数
qsize()	返回队列的大小
empty()	如果队列为空返回True，否则返回False
full()	如果队列已满返回True，否则返回False
put(item,block=0)	把item放到队列中，如果给了block=False表示没有数据时不阻塞，直接报错
get(block=False)	在队列中取一个对象，默认block=True，如果给了block=False表示没有数据时不阻塞，直接报错

示例：

 1.queue.Queue 先进先出队列
 2.queue.LifoQueue,后进先出队列
 3.queue.PriorityQueue,优先级队列
 4.queue.deque，双向队列

     1.先进先出
         #!/usr/bin/env python
         # _*_ coding:utf-8 _*_
         import queue

         #创建一个先进先出队列
         # put 存放数据，是否阻塞，是否有超时时间
         # put也可以传参数:
         #   timeout=2表示如果队列满了等待2秒如果有位置就存进去，如果没有就报错
         #   block=False 表示如果队列满了，不等待直接报错
         # get 取出数据，默认阻塞，队列中没有数据时阻塞等待数据
         # get也可以传参数:
         #   block=False 表示不阻塞，没有数据直接报错
         #   timeout=2   取数据时等待的超时时间
         #
         # Queue()可以接收参数Queue(10)表示最多接收10个数据
         # empty()   如果队列为空返回True，有数据则返回False

         q = queue.Queue()
         # 队列中是否有数据
         print(q.empty())
         # 向队列中添加数据
         q.put(111)
         q.put(222)
         q.put(333)
         # 队列中是否有数据
         print(q.empty())
         # 查看队列中有多少数据
         print("当前队列中有 [%s] 个数据"%q.qsize())
         # 获取数据
         print(q.get())
         # 获取数据
         print(q.get())
         # 取出两个在查看
         print("当前队列中有 [%s] 个数据"%q.qsize())

     2.后进先出队列
         #!/usr/bin/env python
         # _*_ coding:utf-8 _*_
         import queue

         q = queue.LifoQueue()

         q.put(123)
         q.put(456)

         print(q.get())

     3.双向队列
         #!/usr/bin/env python
         # _*_ coding:utf-8 _*_
         import queue

         q = queue.deque()
         # 写入数据
         q.append(")
         q.append(")
         # 在左边插入输入
         q.appendleft(")
         # 获取数据
         print(q.pop())
         # 获取最左边的数据
         print(q.popleft())

     4.优先级队列
         #!/usr/bin/env python
         # _*_ coding:utf-8 _*_
         import queue

         q = queue.PriorityQueue()
         # 优先级队列写入数据需要传两个值，第一个值是优先级数字越小优先级越高，第二个参数是数据
         q.put((1,"test1"))
         q.put((2,"test2"))
         q.put((0,"test0"))

         print(q.get())

生产者消费者模型（队列）

6.自定义线程池

#!/usr/bin/env python
# _*_ coding:utf-8 _*_
import queue
import threading
import time

class Threadpool:
    """
    自定义线程池
    """
    def __init__(self,maxsize=5):
        """
        初始化
        :param maxsize: 队列存放数据的个数
        """
        self.maxsize = maxsize
        # 创建一个队列
        self._q = queue.Queue(maxsize)
        # maxsize多大就创建一个线程对象
        for i in range(maxsize):
            self._q.put(threading.Thread)

    def get_thread(self):
        """
        获取一个线程对象
        等同于创建了一线线程对象t = threading.Thread
        :return:
        """
        return self._q.get()

    def add_thread(self):
        """
        添加一个线程对象到队列中
        :return:
        """
        self._q.put(threading.Thread)

pool = Threadpool(5)

def task(arg,p):
    """
    任务
    :param arg:
    :param p: p 等于接收pool对象
    :return:
    """
    print(arg)
    time.sleep(1)
    # 队列中减少一个线程对象就在添加一个进去，保证队列中始终是5个
    p.add_thread()

for i in range(100):
    t = pool.get_thread()
    obj = t(target=task, args=(i,pool))
    obj.start()