线程、进程和协程

目录

一、队列（queue）

二、线程（threading）

三、进程（multiprocessing）

四、协程（gevent / greenlet）

五、补充知识

一、队列（queue）

1、队列分类

• queue.Queue 先进先出队列；

• q = queue.LifoQueue #后进先出队列，继承Queue；Later in first out;

• q = queue.PriorityQueue #优先级队列，继承Queue；

• 注意：这些队列都是在Python内存中创建的，Python进程结束，队列就自动清空；

#需要添加一个元组（级别，内容），先取出级别小的内容
q = queue.PriorityQueue()
q.put((4,"a"))
q.put((2,"a"))
q.put((3,"a"))
print(q.get())
print(q.get())
print(q.get())
# (2, 'a')
# (3, 'a')
# (4, 'a')

• q =collections.deque #双向队列，支持从任意一端增加删除元素。deque是线程安全的，内存高效的队列，它被设计为从两端追加和弹出都非常快。

from collections import deque
d = deque()
d.append(11)
d.append(22)
d.appendleft(33)#从左边加数据
#数据顺序33,11,22
print(d.pop())#取数据
print(d.popleft())#从左边取数据

2、queue.Queue 先进先出队列

• put(数据内容，block,timeout)：放数据，block为False,不阻塞，多了会报错，默认阻塞，不报错，timeout设置等待时间，超时报错，默认一直等待

• get(数据内容，block,timeout)：取数据，block为False,不阻塞，默认阻塞，timeout设置等待时间，超时报错，默认一直等待

import queue
q = queue.Queue(2)#队列最大长度为2，默认可以无限个
q.put(11)
q.put(22)
# q.put(33,block=False)#直接报错
# q.put(33,timeout=2)#等待2秒后报错
print(q.qsize())#队列长度
print(q.get())
q.task_done()
print(q.get())
q.task_done()#每执行一次取的任务，就执行一次，表示本次任务结束
print(q.empty())#检查队列是否为空
print(q.full())#检查队列是否已满
q.join() #如果每次没有设置task_done，程序就不会往下执行，一直等待,join负责接收task_done的消息，再往下走，两个方法是一个组合，必须成对出现

3、队列和线程应用实例：生产者和消费者模型

为什么要使用生产者和消费者模式？

主要解决了两个问题：解耦和异步

在线程世界里，生产者就是生产数据的线程，消费者就是消费数据的线程。在多线程开发当中，如果生产者处理速度很快，而消费者处理速度很慢，那么生产者就必须等待消费者处理完，才能继续生产数据。同样的道理，如果消费者的处理能力大于生产者，那么消费者就必须等待生产者。为了解决这个问题于是引入了生产者和消费者模式。

什么是生产者消费者模式？

生产者消费者模式是通过一个容器来解决生产者和消费者的强耦合问题。生产者和消费者彼此之间不直接通讯，而通过阻塞队列来进行通讯，所以生产者生产完数据之后不用等待消费者处理，直接扔给阻塞队列，消费者不找生产者要数据，而是直接从阻塞队列里取，阻塞队列就相当于一个缓冲区，平衡了生产者和消费者的处理能力。

这就像，在餐厅，厨师做好菜，不需要直接和客户交流，而是交给前台，而客户去饭菜也不需要不找厨师，直接去前台领取即可，这也是一个解耦的过程。

#生产者和消费者队列、线程结合应用实例
import queue
import threading
import time
q = queue.Queue(20)#创建一个队列，存放三个厨师生产的包子
def productor(arg):
    '''生产者'''
    while True:
        q.put(str(arg) + " - 包子")
def consumer(arg):
    '''消费者'''
    while True:
        print(arg,q.get())
        time.sleep(2)
for i in range(3):
    '''三个厨师'''
    t = threading.Thread(target=productor,args=(i,))
    t.start()
for n in range(100):
    '''100个消费者'''
    t = threading.Thread(target=consumer,args=(n,))
    t.start()

二、线程（threading）

1、创建线程有两种方法：第一种利用系统自带的类threading创建，尽量用系统自带的类创建；

import threading
import time
  
def show(arg):
    time.sleep(1)
    print 'thread'+str(arg)
  
for i in range(10):
    t = threading.Thread(target=show, args=(i,))
    t.start()
  
print 'main thread stop'

上述代码创建了10个“前台”线程，然后控制器就交给了CPU，CPU根据指定算法进行调度，分片执行指令。

2、第二种方法：自定义threading类

#自定义一个继承threading的类和一个run方法
import threading
import time
class MyThread(threading.Thread):
    def __init__(self, func,args):
        self.func = func
        self.args = args
        super(MyThread,self).__init__()
    def run(self):  # 定义每个线程要运行的函数
        self.func(self.args)
        time.sleep(2)
def f(arg):
    print(arg)
t1 = MyThread(f,123)
t2 = MyThread(f,123)
t1.start()#123
t2.start()#123

3、threading对象的基本方法

• start            线程准备就绪，等待CPU调度

• setName     为线程设置名称

• getName     获取线程名称

• setDaemon（True）   守护线程，必须在start() 方法调用之前设置，主线程执行完毕，不等子线程，直接停止。

import threading
def f(x):
    print(x)
t = threading.Thread(target=f,args=(100,))
t.setDaemon(True)  #True表示主线程不等该子线程
t.start() #不代表当前线程会被立即执行
print('end')

• join(n)   在子线程完成运行之前，这个子线程的父线程将一直被阻塞。n表示最多等几秒，该方法使得多线程变得无意义

• run()       线程被cpu调度后自动执行线程对象的run方法

threading模块提供的一些方法：

• threading.currentThread(): 返回当前的线程变量。

• threading.enumerate(): 返回一个包含正在运行的线程的list。正在运行指线程启动后、结束前，不包括启动前和终止后的线程。

• threading.activeCount(): 返回正在运行的线程数量，与len(threading.enumerate())有相同的结果。

4、总结

• 一个应用程序可以有多进程、多线程；默认是单进程、单线程；

• 每一个进程有一个全局解释器锁（GIL），每一次CPU调用只能调用一条线程；

• 如果是IO操作，不占用CPU，单进程，多线程可以提高并发；

• 如果是计算型操作，占用CPU，多进程提高并发；

• Threading用于提供线程相关的操作，线程是应用程序中工作的最小单元。

5、线程锁（Lock、RLock）

• 由于线程之间是进行随机调度，当多个线程同时修改同一条数据时可能会出现脏数据，所以出现了线程锁Lock - 同一时刻只允许一个线程执行操作。

• RLock内部维护着一个Lock和一个counter变量，counter记录了acquire的次数，从而使得资源可以被多次acquire。直到一个线程所有的acquire都被release，其他的线程才能获得资源，也就是说第一个线程执行完第一个函数之后还要重新和第二个线程竞争线程锁，没有得到锁的线程还要继续等待。

为何需要线程锁？

import time
import threading

def addNum():
    global num #在每个线程中都获取这个全局变量
    #num-=1

    temp=num
    #print('--get num:',num )
    time.sleep(0.001) #不加时间，结果为0，加上时间，结果为85，大部分线程在同一时间拿到的是同一个值，
　　　　　　　　　　　　　　这就是线程安全问题，执行到sleep时，cup切换线程
    num =temp-1 #对此公共变量进行-1操作

num = 100  #设定一个共享变量
thread_list = []
for i in range(100):
    t = threading.Thread(target=addNum)
    t.start()
    thread_list.append(t)

for t in thread_list: #等待所有线程执行完毕
    t.join()

print('final num:', num )

 

import threading
import time
NUM = 10
lock1 = threading.Lock()#单次锁，没有释放不能使用，可能出现死锁现象
def f1():
    global NUM
    lock1.acquire()#上锁
    NUM -= 1
    time.sleep(2)
    print(NUM)
    lock1.release()#解锁
for i in range(10):
    t = threading.Thread(target=f1)
    t.start()
lock2 = threading.RLock()#递归锁，可以递归使用
def f2():
    global NUM
    lock2.acquire()#上锁
    NUM -= 1
    lock2.acquire()
    time.sleep(2)
    lock2.release()
    print(NUM)
    lock2.release()#解锁
for i in range(10):
    t = threading.Thread(target=f2)
    t.start()

6、信号量（Semaphore）

　　同时允许一定数量的线程更改数据，信号量是用来控制线程并发数的，BoundedSemaphore或Semaphore管理一个内置的计数 器，每当调用acquire()时-1，调用release()时+1。计数器不能小于0，当计数器为 0时，acquire()将阻塞线程至同步锁定状态，直到其他线程调用release()。(类似于停车位的概念)，BoundedSemaphore与Semaphore的唯一区别在于前者将在调用release()时检查计数 器的值是否超过了计数器的初始值，如果超过了将抛出一个异常。

import threading, time
# 最多允许5个线程同时运行,相当于一个线程锁
semaphore = threading.BoundedSemaphore(5)
def run(n):
    semaphore.acquire()
    time.sleep(3)
    print(n +1)
    semaphore.release()
for i in range(20):
    t = threading.Thread(target=run, args=(i,))
    t.start()

7、事件（event）

• python线程的事件用于主线程控制其他线程的执行，事件主要提供了三个方法 set、wait、clear。

• 事件处理的机制：全局定义了一个“Flag”，如果“Flag”值为 False，那么当程序执行 event.wait 方法时就会阻塞，如果“Flag”值为True，那么event.wait 方法便不再阻塞。

• clear：将“Flag”设置为False，
• set：将“Flag”设置为True
• wait:等待，set后直接pass

import threading
event = threading.Event()
def func(i):
    print(str(i) + "- wait")
    event.wait()#阻塞，满足条件再执行
    print(str(i) + " - start")
for i in range(5):
    t = threading.Thread(target=func,args=(i,))
    t.start()
event.clear()#主动设置成红灯，可以不写
inp = input("\n>>>:")
if inp == "1":
    event.set()#设置为绿灯，event.wait()通行，相当于pass

import threading,time
class Boss(threading.Thread):
    def run(self):
        print("BOSS：今晚大家都要加班到22:00。")
        print(event.isSet())
        event.set()
        time.sleep(5)
        print("BOSS：<22:00>可以下班了。")
        print(event.isSet())
        event.set()
class Worker(threading.Thread):
    def run(self):
        event.wait()
        print("Worker：哎……命苦啊！")
        time.sleep(1)
        event.clear()
        event.wait()
        print("Worker：OhYeah!")
if __name__=="__main__":
    event=threading.Event()
    threads=[]
    for i in range(5):
        threads.append(Worker())
    threads.append(Boss())
    for t in threads:
        t.start()
    for t in threads:
        t.join()

 

8、条件（Condition）

• 使得线程等待，只有满足某条件时，才释放n个线程，下面详细说明实现的两种方法：

#notify(n)n代表释放几个线程
import threading 
def run(n):
    con.acquire()
    con.wait()
    print(n+10)
    con.release() 
if __name__ == '__main__':
    con = threading.Condition()
    for i in range(10):
        t = threading.Thread(target=run, args=(i,))
        t.start() 
    while True:
        inp = input('>>>')
        if inp == 'q':
            break
        con.acquire()
        con.notify(int(inp))#传入几就释放几个线程
        con.release()

#wait_for(func)等待函数的返回结果，如果为True,就释放一个
imoort threading
def func():
    ret = False
    inp = input('>>>')
    if inp == '1':
        ret = True
    return ret
def run(n):
    con.acquire()
    con.wait_for(func)
    print("run the thread: %s" %n)
    con.release()

if __name__ == '__main__':
    con = threading.Condition()
    for i in range(10):
        t = threading.Thread(target=run, args=(i,))
        t.start()

9、Timer

• 定时器，指定n秒后执行某操作

#1秒后释放
from threading import Timer
def hello():
    print("hello, world")
t = Timer(1, hello)
t.start()

10、自定义线程池

#第一种方法，比较low
import threading
import queue
import time
class ThreadingPool:
    def __init__(self,maxsize):
        self.maxsize = maxsize#线程池的最大个数
        self.q = queue.Queue(maxsize)
        for i in range(maxsize):
            #将线程池加满
            self.q.put(threading.Thread)
    def get_thread(self):
        #从线程池取线程
        return self.q.get()
    def add_thread(self):
        #往线程池加线程
        self.q.put(threading.Thread)
pool = ThreadingPool(5)
def func(arg,p):
    print(arg)
    time.sleep(2)
    #每取一次就添加一个线程
    p.add_thread()
for i in range(100):
    thread = pool.get_thread()#获取线程池里的类
    t = thread(target=func,args=(i,pool,))
    t.start()

import queue
import threading
import contextlib
import time

StopEvent = object()


class ThreadPool(object):

    def __init__(self, max_num, max_task_num = None):
        if max_task_num:
            self.q = queue.Queue(max_task_num)
        else:
            self.q = queue.Queue()
        self.max_num = max_num
        self.cancel = False
        self.terminal = False
        self.generate_list = []
        self.free_list = []

    def run(self, func, args, callback=None):
        """
        线程池执行一个任务
        :param func: 任务函数
        :param args: 任务函数所需参数
        :param callback: 任务执行失败或成功后执行的回调函数，回调函数有两个参数1、任务函数执行状态；2、任务函数返回值（默认为None，即：不执行回调函数）
        :return: 如果线程池已经终止，则返回True否则None
        """
        if self.cancel:
            return
        if len(self.free_list) == 0 and len(self.generate_list) < self.max_num:
            self.generate_thread()
        w = (func, args, callback,)
        self.q.put(w)

    def generate_thread(self):
        """
        创建一个线程
        """
        t = threading.Thread(target=self.call)
        t.start()

    def call(self):
        """
        循环去获取任务函数并执行任务函数
        """
        current_thread = threading.currentThread()
        self.generate_list.append(current_thread)

        event = self.q.get()
        while event != StopEvent:

            func, arguments, callback = event
            try:
                result = func(*arguments)
                success = True
            except Exception as e:
                success = False
                result = None

            if callback is not None:
                try:
                    callback(success, result)
                except Exception as e:
                    pass

            with self.worker_state(self.free_list, current_thread):
                if self.terminal:
                    event = StopEvent
                else:
                    event = self.q.get()
        else:

            self.generate_list.remove(current_thread)

    def close(self):
        """
        执行完所有的任务后，所有线程停止
        """
        self.cancel = True
        full_size = len(self.generate_list)
        while full_size:
            self.q.put(StopEvent)
            full_size -= 1

    def terminate(self):
        """
        无论是否还有任务，终止线程
        """
        self.terminal = True

        while self.generate_list:
            self.q.put(StopEvent)

        self.q.queue.clear()

    @contextlib.contextmanager
    def worker_state(self, state_list, worker_thread):
        """
        用于记录线程中正在等待的线程数
        """
        state_list.append(worker_thread)
        try:
            yield
        finally:
            state_list.remove(worker_thread)



# How to use


pool = ThreadPool(5)

def callback(status, result):
    # status, execute action status
    # result, execute action return value
    pass


def action(i):
    print(i)

for i in range(30):
    ret = pool.run(action, (i,), callback)

time.sleep(5)
print(len(pool.generate_list), len(pool.free_list))
print(len(pool.generate_list), len(pool.free_list))
# pool.close()
# pool.terminate()

三、进程（multiprocessing）

线程和进程的关系:

• 进程本质上就是一个程序运行的过程；进程一般由程序、数据集、进程控制块三部分组成；

• 一个程序至少有一个进程，一个进程至少有一个线程；

• 进程在执行过程中拥有独立的内存单元，而多个线程共享内存，从而极大地提高了程序的运行效率。

• 线程是进程的一个实体,是CPU调度和分派的基本单位,它是比进程更小的能独立运行的基本单位.线程自己基本上不拥有系统资源,只拥有一点在运行中必不可少的资源(如程序计数器,一组寄存器和栈)但是它可与同属一个进程的其他的线程共享进程所拥有的全部资源. 一个线程可以创建和撤销另一个线程;同一个进程中的多个线程之间可以并发执行。

1、创建进程：由于进程之间的数据需要各自持有一份，所以创建进程需要的非常大的开销

• os.getppid  获取父进程的进程ID

• os.getpid  获取当前进程的进程ID

• self.name 进程名（类名-1），线程也是

from multiprocessing import Process
import time
def func(name):
    time.sleep(2)
    print('hello %s %s'%(name,time.ctime()))

if __name__=='__main__':
    l=[]
    for i in range(3):
        p=Process(target=func,args=('charlie',))
        p.daemon=True # 守护进程，直接打印ending
        p.start()
        l.append(p)
    # for p in l:
    #     p.join()# 等待所有子进程结束，再打印ending
    print('ending...')

 

2、进程数据共享

# 方法一，Array
from multiprocessing import Process, Array
import time
def Foo(i,arg):
    time.sleep(2)
    for item in arg:
        print(i, '---->', item,time.ctime())
    print("========")
if __name__ == '__main__':
    temp = Array('i', 5)#数组必须指定类型和大小
    p_list=[]
    for i in range(5):
        p = Process(target=Foo, args=(i,temp,))
        p_list.append(p)
        p.start()
    for p in p_list:
        p.join()
    print('ending..',time.ctime())
#方法二：manage.dict()共享数据，列表同理：manage.list(range(5))
from multiprocessing import Process, Manager
import time
def Foo(i,arg):
    arg[i] = 100 + i
    print(arg.values(),time.ctime())
if __name__ == '__main__':
    manage = Manager()
    dic = manage.dict()
    p_list=[]
    for i in range(5):
        p = Process(target=Foo, args=(i,dic,))
        p.start()
        p_list.append(p)
    for p in p_list:
        p.join()
    print('ending...',time.ctime()) # 同一时间打印所有进程

 

#Array类型对应表
# 'c': ctypes.c_char,  'u': ctypes.c_wchar,
# 'b': ctypes.c_byte,  'B': ctypes.c_ubyte,
# 'h': ctypes.c_short, 'H': ctypes.c_ushort,
# 'i': ctypes.c_int,   'I': ctypes.c_uint,
# 'l': ctypes.c_long,  'L': ctypes.c_ulong,
# 'f': ctypes.c_float, 'd': ctypes.c_double

3、进程数据通信（即一个进程去更改另一个进程的数据）

• 进程队列（Queue）

from multiprocessing import Process, Queue

def f(i,q):
    q.put(i*i+1)
    print('son process',id(q))

if __name__ == '__main__':
    q = Queue()
    print('main process',id(q))
    for i in range(3):
        p = Process(target=f, args=(i,q,))
        p.start()
    print(q.get())
    print(q.get())
    print(q.get())

• 管道（Pipe）

from multiprocessing import Process, Pipe

def f(conn):
    conn.send([12, {"name":"yuan"}, 'hello'])
    response=conn.recv()
    print("response",response)
    conn.close()
    print("q_ID2:",id(conn))

if __name__ == '__main__':

    parent_conn, child_conn = Pipe()
    print("q_ID1:",id(child_conn))
    p = Process(target=f, args=(child_conn,))
    p.start()
    print(parent_conn.recv())   # prints "[42, None, 'hello']"
    parent_conn.send("儿子你好!")
    p.join()

4、进程锁

进程之间数据默认不共享，所以不存在同步操作问题，一般不需要进程锁，但是也有一些资源是共享的，例如屏幕资源，每个进程都想在同一时刻同一行输出，就会出现串行。

#进程里的单程锁，连环锁，事件，信号量，和线程里的用法一样
from multiprocessing import Lock,RLock,Event,BoundedSemaphore

def func(l,i):
    # 用with l: 就不用解锁了
    # 加进程锁是为了防止输出串行
    l.acquire()
    print('hello %s'%i)
    l.release()

if __name__=="__main__":
    lock=Lock()
    for i in range(10):
        p=Process(target=func,args=(lock,i))
        p.start()

5、进程池

• 进程池内部维护一个进程序列，当使用时，则去进程池中获取一个进程，如果进程池序列中没有可供使用的进进程，那么程序就会等待，直到进程池中有可用进程为止。

• 进程池中有两个方法：apply（）、apply_async（）

from multiprocessing import Pool
import time
def Foo(i):
    time.sleep(1)
    print(i+1)
if __name__ == "__main__":
    pool = Pool(5)
    for i in range(30):
        #pool.apply(Foo,(i,))#所有进程串行执行，一个接一个
        pool.apply_async(func=Foo, args=(i,))#异步执行
    #pool.terminate()#无论当前进程是否执行完毕,直接关闭
    pool.close()# 所有进程执行完毕后再关闭
    pool.join() #进程池的join前面必须加上close和terminate其中一个

总结：IO密集型使用多线程，因为不调用CPU；计算密集型使用多进程，需要调用CPU；

四、协程（gevent / greenlet）

1、线程和进程的操作是由程序触发系统接口，最后的执行者是系统；协程的操作则是程序员。

2、协程存在的意义：对于多线程应用，CPU通过切片的方式来切换线程间的执行，线程切换时需要耗时（保存状态，下次继续）。协程，则只使用一个线程，在一个线程中规定某个代码块执行顺序。

3、协程的适用场景：当程序中存在大量不需要CPU的操作时（IO），适用于协程，即高并发的io操作，协程比多线程节省时间；

4、greenlet是python的一个C扩展，来源于Stackless python，旨在提供可自行调度的‘微线程’， 即协程；greenlet用switch来表示协程的切换，从一个协程切换到另一个协程需要显式指定。

from greenlet import greenlet
def test1():
    print(12)
    gr2.switch()
    print(34)
    gr2.switch()
def test2():
    print(56)
    gr1.switch()
    print(78)
gr1 = greenlet(test1)
gr2 = greenlet(test2)
gr1.switch()
#12，56，34，78

5、gevent是第三方库，通过greenlet实现协程，其基本思想是：

• greenlet可以实现协程，不过每一次都要人为的去指向下一个该执行的协程，显得太过麻烦。python还有一个比greenlet更强大的并且能够自动切换任务的模块gevent

• 当一个greenlet遇到IO操作时，比如访问网络，就自动切换到其他的greenlet，等到IO操作完成，再在适当的时候切换回来继续执行。由于IO操作非常耗时，经常使程序处于等待状态，有了gevent为我们自动切换协程，就保证总有greenlet在运行，而不是等待IO。

• 由于切换是在IO操作时自动完成，所以gevent需要修改Python自带的一些标准库，这一过程在启动时通过monkey patch完成：

from gevent import monkey;monkey.patch_all()
import gevent
import requests
def f(url):
    print('GET:%s'%url)
    response = requests.get(url)
    data = response.text
    print("%d bytes received from %s."%(len(data),url))
gevent.joinall([
    gevent.spawn(f,"http://www.baidu.com/"),
    gevent.spawn(f,"http://www.yahoo.com/"),
    gevent.spawn(f,"http://www.python.org")
])
# GET:http://www.baidu.com/
# GET:http://www.yahoo.com/
# GET:http://www.python.org
# 2381 bytes received from http://www.baidu.com/.
# 48970 bytes received from http://www.python.org.
# 529733 bytes received from http://www.yahoo.com/.

五、补充知识

1、并发：系统具有处理多个任务的能力；

2、并行：系统具有同时处理多个任务的能力；并行是并发的子集；

3、同步：当进程执行到一个IO（等待外部数据）的时候，必须等待；比如打电话，一直等到对方接听；

4、异步：当进程执行到一个IO（等待外部数据）的时候，不等待，直到数据接收成功，再回来处理；比如发短信，不需要等到对方回复，可以先去做别的，收到后再来回复短信；

5、上下文管理

with Manager() as manager

#相当于: manager=Manager()
#最后不用手动关闭； 

6、回调函数：就是某个动作或函数执行成功后再去执行的函数；

 7、Python3中的进程池和线程池

from concurrent.futures import ThreadPoolExecutor   # 线程池
from concurrent.futures import ProcessPoolExecutor  # 进程池
import time

def task(arg):
    print(arg)
    time.sleep(1)

pool = ThreadPoolExecutor(5)      # 创建线程池
# pool = ProcessPoolExecutor(5)   # 创建进程池

for i in range(50):
    pool.submit(task,i)