进程 线程 协程

• 一、进程的概念

假如有两个程序A和B，首先执行A程序的时候遇到数据阻塞（A程序在等待数据的输入），那么这个时候CPU就是空闲的，我们为了充分利用资源能不能先将A程序撂一边，先执行B程序，等到A程序接收到数据再将B程序暂停继续执行A程序呢？答案显然是可以的，这个时候有一个关键词：切换。也就是这就是CPU从A切换到B,再从B切换到A。

那么既然是切换，那么就涉及到状态的保存，状态的恢复，以及程序A与程序B所占用的资源（数据，CPU，键盘等等），自然而然就需要有一个东西可以去记录A程序和B程序的资源，以及如何去识别A和B，这个时候就有了一个进程的抽象。

进程定义

进程就是一个程序在一个数据集运行的一次动态执行过程

进程一般由 程序、数据集和进程控制块 三部分组成

我们编写的程序用来描述进程要完成的功能以及如何完成；

数据集则是程序在执行过程中用到的资源；

进程控制块用来记录进程的外部特征，描述进程的执行变化过程，系统可以利用它来控制和管理进程，它是系统感知进程存在的唯一标志。

• 二、线程的概念

线程的出现是为了降低上下文切换的消耗，提高系统的并发性，并突破一个进程只能干一样事的缺陷， 使到进程内并发成为可能。

假设，一个文本程序，需要接受键盘输入，将内容显示在屏幕上，还需要保存信息到硬盘中。若只有 一个进程，势必造成同一时间只能干一样事的尴尬（当保存时，就不能通过键盘输入内容）。若有多 个进程，每个进程负责一个任务，进程A负责接收键盘输入的任务，进程B负责将内容显示在屏幕上的 任务，进程C负责保存内容到硬盘中的任务。这里进程A，B，C间的协作涉及到了进程通信问题，而且 有共同都需要拥有的东西-------文本内容，不停的切换造成性能上的损失。若有一种机制，可以使 任务A，B，C共享资源，这样上下文切换所需要保存和恢复的内容就少了，同时又可以减少通信所带 来的性能损耗，那就好了。是的，这种机制就是线程。

线程定义

线程也叫轻量级进程，它是一个基本的CPU执行单元，也是程序执行过程中的最小单元，由线程ID、程序 计数器、寄存器集合和堆栈共同组成。

线程的引入减小了程序并发执行时的开销，提高了操作系统的并发 性能。线程没有自己的系统资源。

• 三、进程和线程的关系区别

1 一个程序至少有一个进程,一个进程至少有一个线程.(进程可以理解成线程的容器)

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

3 线程在执行过程中与进程还是有区别的。每个独立的线程有一个程序运行的入口、顺序执行序列和 程序的出口。但是线程不能够独立执行，必须依存在应用程序中，由应用程序提供多个线程执行控制。

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

5.进程是最小的资源单位，线程是最小的执行单位

• 四、为何要开多线程

多线程指的是，在一个进程中开启多个线程，简单的讲：如果多个任务共用一块地址空间，那么必须在一个进程内开启多个线程。详细的讲分为4点：

　　1. 多线程共享一个进程的地址空间

      2. 线程比进程更轻量级，线程比进程更容易创建可撤销，在许多操作系统中，创建一个线程比创建一个进程要快10-100倍，在有大量线程需要动态和快速修改时，这一特性很有用

      3. 若多个线程都是cpu密集型的，那么并不能获得性能上的增强，但是如果存在大量的计算和大量的I/O处理，拥有多个线程允许这些活动彼此重叠运行，从而会加快程序执行的速度。

      4. 在多cpu系统中，为了最大限度的利用多核，可以开启多个线程，比开进程开销要小的多。（这一条并不适用于python）

• 五、线程

（1）线程的两种调用方式

直接调用

import threading,time
def hi(num):
    start_time = time.time()
    print('say hi %d'%num)
    time.sleep(3)
    stop_time = time.time()
    print('总共用的时间是%s'%(stop_time-start_time))

if __name__ == '__main__':
    t1 = threading.Thread(target=hi,args=(10,))
    t1.start()
    t2 = threading.Thread(target=hi, args=(9,))
    t2.start()
    # say hi 10
    # say hi 9
    # 总共用的时间是3.000171422958374
    # 总共用的时间是3.001171588897705

 　　自定义threading类调用

import threading,time
class Mythreading(threading.Thread):
    def __init__(self,num):
        threading.Thread.__init__(self)
        self.num = num
    def run(self):      ##  必须要重写run（）方法
        start_time = time.time()
        print('say hi %d'%self.num)
        time.sleep(3)
        stop_time = time.time()
        print('总共用的时间是%s'%(stop_time-start_time))

if __name__ == '__main__':
    t = Mythreading(10)
    t.start()
    time.sleep(2)
    print('ending....')
    # say hi 10
    # ending....
    # 总共用的时间是3.000171422958374

（2）join方法

join方法：

1.join方法的作用是阻塞主进程（挡住，无法执行join以后的语句），专注执行多线程。

2.多线程多join的情况下，依次执行各线程的join方法，前头一个结束了才能执行后面一个。

3.无参数，则等待到该线程结束，才开始执行下一个线程的join。

import threading,time
def music():
    print('start to music %s'%time.ctime())
    time.sleep(3)
    print('stop to music %s'%time.ctime())

def game():
    print('start to play game %s'%time.ctime())
    time.sleep(5)
    print('stop to play game %s'%time.ctime())

if __name__ == '__main__':
    t1 = threading.Thread(target=music)
    t1.start()
    t2 = threading.Thread(target=music)
    t2.start()
    t1.join()       ##  这里加了join方法，也就是说t1没有执行完后面的代码就不走了
    print('ending.....')
    # start to music Fri Apr 10 23:50:07 2020
    # start to music Fri Apr 10 23:50:07 2020
    # stop to music Fri Apr 10 23:50:10 2020
    # ending.....
    # stop to music Fri Apr 10 23:50:10 2020

（3）setDaemon方法

setDaemon（True）：

setDaemon一定要在start方法之前加，设置为守护线程。结果和join方法相反

主线程执行完要看子线程执行结束情况，如果子线程还没结束，那么主线程就需要等待子线程结束再一起退出。这时子线程1如果设置成守护线程，那么主线程执行结束就直接无视子线程1了，不需要等子线程1了。　

import threading,time
def music():
    print('start to music %s'%time.ctime())
    time.sleep(3)
    print('stop to music %s'%time.ctime())

def game():
    print('start to play game %s'%time.ctime())
    time.sleep(5)
    print('stop to play game %s'%time.ctime())

if __name__ == '__main__':
    t1 = threading.Thread(target=music)
    t2 = threading.Thread(target=game)
    t2.setDaemon(True)      ##  setDaemon 必须在start（）前设置
    t1.start()
    t2.start()
    print('ending....',time.ctime())
    # start to music Sat Apr 11 10:23:22 2020
    # start to play game Sat Apr 11 10:23:22 2020
    # ending.... Sat Apr 11 10:23:22 2020
    # stop to music Sat Apr 11 10:23:25 2020

（4）其它方法

# run():  线程被cpu调度后自动执行线程对象的run方法
# start():启动线程活动。
# isAlive(): 返回线程是否活动的。
# getName(): 返回线程名。
# setName(): 设置线程名。

threading模块提供的一些方法：
# threading.currentThread(): 返回当前的线程变量。
# threading.enumerate(): 返回一个包含正在运行的线程的list。正在运行指线程启动后、结束前，不包括启动前和终止后的线程。
# threading.activeCount(): 返回正在运行的线程数量，与len(threading.enumerate())有相同的结果。

• 五、并行&并发　　同步&异步

并发&并行
并行：系统具有同时处理多个任务（动作）的能力，通俗点就是多核CPU各自同一时刻运行着不同的应用。

并发：系统具有处理多个任务（动作）的能力，通俗点来说就是单核CPU可以做到来回切换处理QQ音乐、暴风影音、微信等应用的能力，但是要注意一点，这不是同一时刻单核CPU可以处理多个应用，而是因为切换速度很快，让你感知不到这个切换。

并发和并行的关系：并行是并发的子集

同步&异步

同步：执行过程中遇到IO阻塞（等待外部数据）时，选择------------等：不继续接下来的操作，直到等到了数据再继续接下来的操作---例如：打电话

异步： 　　　　　　　　　　　　　　　　　　　　　　 ----------不等：继续其它操作，直到数据到了在继续刚刚的操作---例如：发短信

• 六、GIL（全局解释器锁）

In CPython, the global interpreter lock, or GIL, is a mutex that prevents multiple native threads from executing Python bytecodes at once. This lock is necessary mainly because CPython’s memory management is not thread-safe. (However, since the GIL exists, other features have grown to depend on the guarantees that it enforces.)

上面的核心意思就是，无论你启多少个线程，你有多少个cpu, Python在执行的时候会淡定的在同一时刻只允许同一个进程的一个线程运行

假设我们需要完成两个功能，累加和类乘，现在分别用串行和多线程来计算运行所用的时间

import threading,time
start = time.time()
def add():
    num = 0
    for i in range(100000000):
        num += i
    print('add运行结束了')

def mul():
    num = 1
    for i in range(1,100000):
        num *= i
    print('mul运行结束了')

add()
mul()
print('ending。。。')
print('消耗的时间是:',(time.time()-start))
# add运行结束了
# mul运行结束了
# ending。。。
# 消耗的时间是: 13.369764566421509

import threading,time
start = time.time()
def add():
    num = 0
    for i in range(100000000):
        num += i
    print('add运行结束了')

def mul():
    num = 1
    for i in range(1,100000):
        num *= i
    print('mul运行结束了')

t1 = threading.Thread(target=add)
t2 = threading.Thread(target=mul)
t1.start()
t2.start()
t1.join()
t2.join()
print('ending。。。')
print('消耗的时间是:',(time.time()-start))
# mul运行结束了
# add运行结束了
# ending。。。
# 消耗的时间是: 13.208755731582642

可以看到，串行用到的时间是（13.369764566421509），多线程所用的时间是（13.208755731582642）。这次用到的Python解释器是3.7，在这里已经优化很多了。如果这是在2.7中运行的话，多线程运行的时间要多于串行所用的时间，这是为什么？

这是因为Python解释器中加了一把GIL锁，正因为有这把锁，同一时刻同一个进程中只允许有一个线程在运行，那么也就是在计算中不能用两个CPU来处理两个函数

我们可以看到上面的过程，add函数和mul函数在争夺锁出去运行，可能先是add拿到权限了，出去运行了一会儿时间轮循（也就是过一段时间就要退出CPU）进行切换，add回去了，锁被mul拿到了，运行了一会儿又回来了，add又出去继续运行。。。这样一个过程需要大量的切换。发过来我们看，如果是串行的话，运行完add自然就轮到mul运行了，这中间没有切换的过程，所以效率肯定要比多线程的要快。

总结：

1、任务分为：IO密集型 和计算密集型

2、对于IO密集型：Python的 多线程 是有效的，也可以用进程+协程

　　对于计算密集型：Python就不适用了，Python没有比较有效的方法适用计算密集型的任务。

• 七、同步锁

我们现在有一个需求：用一百个线程来做一个累减的操作

import threading,time
num = 100
def num_reduce():
    global num
    temp = num
    time.sleep(0.001)
    num = temp-1

t_list = []
for i in range(100):
    t = threading.Thread(target=num_reduce)
    t.start()
    t_list.append(t)
for j in t_list:
    j.join()

print(num)      ##  79  78  76  79  76

可以看到，结果并不唯一，为什么结果不是0？

这是因为，假如有一百个人来代表一百个线程，首先第一个人易烊千玺拿到num=100，然后进入IO阻塞，释放出锁，这时第二个人胡歌拿到锁了，拿到的num仍然是100，进入IO阻塞，释放锁，第三个人蔡徐坤拿到锁，拿到的num仍然是100.。。。可能到第八个人的时候易烊千玺time.sleep结束了，num变为99，这时第八个人王俊凯进来拿到的num就是99了。。。这个过程下去

我们来看一张图

归根到底，就是因为线程共用数据资源，那我们把资源共用的那一部分锁住不就行了吗，这个时候就用到同步锁了

import threading,time
num = 100
lock = threading.Lock()     ##  创建一个同步锁对象
def num_reduce():
    global num
    lock.acquire()      ##  上锁
    temp = num
    time.sleep(0.001)
    num = temp-1
    lock.release()      ##  放锁

t_list = []
for i in range(100):
    t = threading.Thread(target=num_reduce)
    t.start()
    t_list.append(t)
for j in t_list:
    j.join()

print(num)     ##   0

• 八、死锁和递归锁

有两个人犬痣聋和蔡徐坤，犬痣聋手里拿着一个篮球，蔡徐坤手里拿着一个足球，蔡徐坤想要犬痣聋手里的篮球，而犬痣聋想要蔡徐坤手里的足球，谁也不愿意先给对方，两人就这样僵持着。

其实线程也会出现这种情况，就是死锁

import threading,time

Lock_A = threading.Lock()
Lock_B = threading.Lock()

class Mythread(threading.Thread):
    def sectionA(self):
        Lock_A.acquire()
        print('%s拿到Lock_A'%self.name)
        time.sleep(2)

        Lock_B.acquire()
        print('%s拿到Lock_B'%self.name)
        time.sleep(1)

        Lock_B.release()
        Lock_A.release()

    def sectionB(self):
        Lock_B.acquire()
        print('%s拿到Lock_B' % self.name)
        time.sleep(2)

        Lock_A.acquire()
        print('%s拿到Lock_A' % self.name)
        time.sleep(1)

        Lock_A.release()
        Lock_B.release()

    def run(self):
        self.sectionA()
        self.sectionB()

if __name__ == '__main__':
    t_list = []
    for i in range(5):
        t = Mythread()
        t.start()
        t_list.append(t)
    for j in t_list:
        j.join()

    print('ending。。。')
    
    # Thread-1拿到Lock_A
    # Thread-1拿到Lock_B
    # Thread-1拿到Lock_B
    # Thread-2拿到Lock_A

造成死锁的原因是线程2拿到了A锁，在等着拿B锁，而线程1拿到了B锁，在等着拿A锁，两个线程谁也不让着谁，那就只能干耗着

那我们很容易就想到解决死锁的办法：我把A锁和B锁绑定在一起，拿到A锁就只有我能拿B锁，其他人都不能拿，这不就解决了吗？

这就是递归锁（RLock）

import threading,time

l_Lock = threading.RLock()      ##  递归锁对象

class Mythread(threading.Thread):
    def sectionA(self):
        l_Lock.acquire()        ##  account = 1
        print('%s拿到Lock_A'%self.name)
        time.sleep(2)

        l_Lock.acquire()        ##  account = 2
        print('%s拿到Lock_B'%self.name)
        time.sleep(1)

        l_Lock.release()        ##  account = 1
        l_Lock.release()        ##  account = 0

    def sectionB(self):
        l_Lock.acquire()
        print('%s拿到Lock_B' % self.name)
        time.sleep(2)

        l_Lock.acquire()
        print('%s拿到Lock_A' % self.name)
        time.sleep(1)

        l_Lock.release()
        l_Lock.release()

    def run(self):
        self.sectionA()
        self.sectionB()

if __name__ == '__main__':
    t_list = []
    for i in range(5):
        t = Mythread()
        t.start()
        t_list.append(t)
    for j in t_list:
        j.join()

    print('ending。。。')
    # Thread-1拿到Lock_A
    # Thread-1拿到Lock_B
    # Thread-1拿到Lock_B
    # Thread-1拿到Lock_A
    # Thread-3拿到Lock_A
    # Thread-3拿到Lock_B
    # Thread-3拿到Lock_B
    # Thread-3拿到Lock_A
    # Thread-5拿到Lock_A
    # Thread-5拿到Lock_B
    # Thread-2拿到Lock_A
    # Thread-2拿到Lock_B
    # Thread-4拿到Lock_A
    # Thread-4拿到Lock_B
    # Thread-4拿到Lock_B
    # Thread-4拿到Lock_A
    # Thread-2拿到Lock_B
    # Thread-2拿到Lock_A
    # Thread-5拿到Lock_B
    # Thread-5拿到Lock_A
    # ending。。。

递归锁实现流程：

Thread1拿到递归锁（RLock），这时递归锁的计时器标识account=1，其它人就只能等着，只有account=0时其他人才能抢锁。 

• 九、同步对象（event）

事件是一个简单的同步对象；事件表示内部标志，线程可以等待标志被设置，或者自己设置或清除标志。

创建一个同步对象：event = threading.Event()

客户端线程可以等待标志被设置

event.wait()

服务器线程可以设置或重置它

event.set()
event.clear()

如果设置了标志，wait方法不会做任何事情。如果标志被清除，wait将阻塞，直到它再次被设置。任何数量的线程都可能等待相同的事件。

通俗点就是如果一个线程A设置为同步对象，另外几个线程有wait（）方法，那么这些线程就得等待线程A

import threading,time
class Boss(threading.Thread):
    def run(self):
        print("BOSS：今晚大家都要加班到22:00。")
        print(event.isSet())      ## False，wait后面不能走
        event.set()         ## 设置为True,wait 可以走了
        time.sleep(5)
        print("BOSS：<22:00>可以下班了。")
        print(event.isSet())  ## False
        event.set()   ## 设置为True，wait后面可以走了
class Worker(threading.Thread):
    def run(self):
        event.wait()
        print("Worker：哎……命苦啊！")
        time.sleep(1)
        event.clear()   ## 清除标识，也就是改为False，wait不能走了
        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()

 

• 十、同步信号量（Semaphore）

同步信号量可以控制同时可以有几个线程去执行，本质上也是一把锁

import threading,time
class Mythread(threading.Thread):
    def run(self):
        Semaphore.acquire()
        print(self.name)
        time.sleep(3)
        Semaphore.release()

if __name__ == '__main__':
    t_list = []
    Semaphore = threading.Semaphore(5)      ##  同时允许五个线程
    for i in range(100):
        t = Mythread()
        t.start()
        t_list.append(t)
    for j in t_list:
        j.join()
    print('ending...')

• 十一、线程队列------多线程利器

我们来看一下两个线程来删除一个列表的值时会出现什么样的情况

import threading,time

li=[1,2,3,4,5]

def pri():
    while li:
        a=li[-1]
        print(a)
        time.sleep(1)
        try:
            li.remove(a)
        except Exception as e:
            print('----',a,e)

t1=threading.Thread(target=pri,args=())
t1.start()
t2=threading.Thread(target=pri,args=())
t2.start()
# 5
# 5
# 4
# ---- 5 list.remove(x): x not in list
# 4
# 3
# ---- 4 list.remove(x): x not in list
# 3
# 2
# ---- 3 list.remove(x): x not in list
# 2
# 1
# ---- 2 list.remove(x): x not in list
# 1
# ---- 1 list.remove(x): x not in list

可以看得出来，列表是不安全的数据结构，当两个线程同时共享同一个列表时，列表可能会出错

所以在线程中，用队列相比列表安全得多了

1、队列

队列也是一种数据结构，效果和列表一样，只适用于线程和进程中

queue队列类的方法

创建一个“队列”对象
import Queue
q = Queue.Queue(maxsize = 10)
Queue.Queue类即是一个队列的同步实现。队列长度可为无限或者有限。可通过Queue的构造函数的可选参数maxsize来设定队列长度。如果maxsize小于1就表示队列长度无限。

将一个值放入队列中
q.put(10)
调用队列对象的put()方法在队尾插入一个项目。put()有两个参数，第一个item为必需的，为插入项目的值；第二个block为可选参数，默认为
1。如果队列当前为空且block为1，put()方法就使调用线程暂停,直到空出一个数据单元。如果block为0，put方法将引发Full异常。

将一个值从队列中取出
q.get()
调用队列对象的get()方法从队头删除并返回一个项目。可选参数为block，默认为True。如果队列为空且block为True，
get()就使调用线程暂停，直至有项目可用。如果队列为空且block为False，队列将引发Empty异常。

Python Queue模块有三种队列及构造函数:
1、Python Queue模块的FIFO队列先进先出。   class queue.Queue(maxsize)
2、LIFO类似于堆，即先进后出。               class queue.LifoQueue(maxsize)
3、还有一种是优先级队列级别越低越先出来。        class queue.PriorityQueue(maxsize)

此包中的常用方法(q = Queue.Queue()):
q.qsize() 返回队列的大小
q.empty() 如果队列为空，返回True,反之False
q.full() 如果队列满了，返回True,反之False
q.full 与 maxsize 大小对应
q.get([block[, timeout]]) 获取队列，timeout等待时间
q.get_nowait() 相当q.get(False)
非阻塞 q.put(item) 写入队列，timeout等待时间
q.put_nowait(item) 相当q.put(item, False)
q.task_done() 在完成一项工作之后，q.task_done() 函数向任务已经完成的队列发送一个信号
q.join() 实际上意味着等到队列为空，再执行别的操作

 

2、三种队列模式：

（1）先进先出FIFO（first in first out）（默认）

import queue
q = queue.Queue(3)   ##  创建一个线程队列,参数3代表最多能放3个队列
q.put(21)
q.put('hello')
q.put({'name':'alex'})
# q.put((12,23),False)        ##  put(self, item, block=True, timeout=None)   这里block默认值为True，如果满了则不能塞数据，必须要有数据被取了才能往里塞，队列会卡在这里。如果block设置为False，则满了再塞就报错
while True:
    data = q.get()          ##  get(self, block=True, timeout=None)  这里block默认值为True，如果空了就等待，直到有数据被塞入，如果设置为False则空了就报错
    print(data)         
# 21
# hello
# {'name': 'alex'}

（2）先进后出LIFO（later in first out）

import queue
q = queue.LifoQueue(3)

q.put(123)
q.put('hello')
q.put({'name':'alex'})

while 1:
    date = q.get(block=False)
    print(date)
    print('------------------')
# {'name': 'alex'}
# ------------------
# hello
# ------------------
# 123
# ------------------

（3）优先级

import queue
q = queue.PriorityQueue()
q.put([2,23])       ##  第一个元素是优先级，数字越小优先级越高
q.put([4,'hello'])
q.put([3,{'name':'alex'}])
while True:
    data = q.get()
    print(data)
# [2, 23]
# [3, {'name': 'alex'}]
# [4, 'hello']

3、生产者消费者模型

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

在线程世界中，生产者就是生产数据的线程，消费者就是消费数据的线程。如果生产者生产数据很快，消费者消费数据很慢，那么生产者就需要等待消费者处理完，才能继续产生数据；反之也一样，消费者就必须要等待生产者生产出数据，才能继续处理。

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

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

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

import threading,queue,random,time

q = queue.Queue()

def Produce(name):
    count = 1
    while count < 4:
        print('开始制作包子...')
        time.sleep(random.randrange(3))
        q.put(count)
        print('Produce %s 制作好了第%s个包子...'%(name,count))
        count += 1
        print('ok')

def Consumer(name):
    count = 1
    while count<4:
        time.sleep(random.randrange(4))
        if not q.empty():
            date = q.get()
            print(date)
            print('33[32;1mConsumer%s吃了第%s个包子...33[0m'%(name,date))
            count += 1
        else:
            print('----没有包子了----')


p1 = threading.Thread(target=Produce,args=('A厨师',))
c1 = threading.Thread(target=Consumer,args=('B消费者',))
p1.start()
c1.start()
# 开始制作包子...
# ----没有包子了----
# Produce A厨师 制作好了第1个包子...
# ok
# 开始制作包子...
# 1
# ConsumerB消费者吃了第1个包子...
# Produce A厨师 制作好了第2个包子...
# ok
# 开始制作包子...
# Produce A厨师 制作好了第3个包子...
# ok
# 2
# ConsumerB消费者吃了第2个包子...
# 3
# ConsumerB消费者吃了第3个包子...

• 十二、进程

1、进程的调用方式

（1）直接调用

import multiprocessing,time
def movie():
    print('begin to movie ',time.ctime())
    time.sleep(1)
    print('stop to movie ',time.ctime())

if __name__ == '__main__':
    p1 = multiprocessing.Process(target=movie)
    p2 = multiprocessing.Process(target=movie)
    p3 = multiprocessing.Process(target=movie)
    p1.start()
    p2.start()
    p3.start()
    p1.join()
    p2.join()
    p3.join()
    print('ending......')
    # begin to movie  Sun Apr 12 14:12:23 2020
    # begin to movie  Sun Apr 12 14:12:23 2020
    # begin to movie  Sun Apr 12 14:12:23 2020
    # stop to movie  Sun Apr 12 14:12:24 2020
    # stop to movie  Sun Apr 12 14:12:24 2020
    # stop to movie  Sun Apr 12 14:12:24 2020
    # ending......

（2）继承调用

import multiprocessing,time
class Myprocess(multiprocessing.Process):
    def run(self):
        print(self.name,'begin to run',time.ctime())
        time.sleep(3)
        print(self.name,'stop to run',time.ctime())

if __name__ == '__main__':
    p_list = []
    for p in range(3):
        p = Myprocess()
        p.start()
        p_list.append(p)
    for j in p_list:
        j.join()
    print('ending....')
    
    # Myprocess-1 begin to run Sun Apr 12 14:24:00 2020
    # Myprocess-2 begin to run Sun Apr 12 14:24:00 2020
    # Myprocess-3 begin to run Sun Apr 12 14:24:00 2020
    # Myprocess-1 stop to run Sun Apr 12 14:24:03 2020
    # Myprocess-2 stop to run Sun Apr 12 14:24:03 2020
    # Myprocess-3 stop to run Sun Apr 12 14:24:03 2020
    # ending....

 

2、daemon方法（守护进程）

import multiprocessing,time
class Myprocess(multiprocessing.Process):
    def run(self):
        print(self.name,'begin to run',time.ctime())
        time.sleep(3)
        print(self.name,'stop to run',time.ctime())

if __name__ == '__main__':
    for p in range(3):
        p = Myprocess()
        p.daemon = True     ##  这里deamon是实例属性
        p.start()

    print('ending....')
    # ending....

　　

　　3、进程与子进程的pid

import time,os
from multiprocessing import Process

def info(name):
    time.sleep(1)
    print('name:',name)
    print('parent procces:',os.getppid())       ##      父进程
    print('pid id',os.getpid())



if __name__ == '__main__':
    ##  主进程
    info('alex')
    print('------------------')

    ##  子进程
    p = Process(target=info,args=('yuan',))
    p.start()
    p.join()

    print('end')
    # name: alex
    # parent procces: 3404      ------------->  pycharm 的进程号
    # pid id 1120               ------------->  主进程pid
    # ------------------
    # name: yuan
    # parent procces: 1120      
    # pid id 7868               ------------->  子进程的pid
    # end

4、Process类

构造方法：

Process([group [, target [, name [, args [, kwargs]]]]])

　　group: 线程组，目前还没有实现，库引用中提示必须是None； 
　　target: 要执行的方法； 
　　name: 进程名； 
　　args/kwargs: 要传入方法的参数。

实例方法：

　　is_alive()：返回进程是否在运行。

　　join([timeout])：阻塞当前上下文环境的进程程，直到调用此方法的进程终止或到达指定的timeout（可选参数）。

　　start()：进程准备就绪，等待CPU调度

　　run()：strat()调用run方法，如果实例进程时未制定传入target，这star执行t默认run()方法。

　　terminate()：不管任务是否完成，立即停止工作进程

属性：

　　daemon：和线程的setDeamon功能一样

　　name：进程名字。

　　pid：进程号。

• 十三、进程间的通信

（1）进程队列Queue

import multiprocessing,time
def run(q):
    time.sleep(1)
    q.put(123)
    q.put('hello')
    q.put({'name':'alex'})
    
if __name__ == '__main__':
    q = multiprocessing.Queue() ##  创建进程队列对象
    p = multiprocessing.Process(target=run,args=(q,))
    p.start()
    for i in range(3):
        print(q.get())

    print('ending....')
    # 123
    # hello
    # {'name': 'alex'}
    # ending....

注意：进程队列和线程队列是不一样的，线程队列的数据是共享的，而进程队列不是，例如上面的例子，子进程把数据放到队列里，实际上是拷贝了一份数据给父进程，这也就是为什么进程间通信很耗资源。

（2）管道通信Pipe

import multiprocessing,time
def son(conn):
    print('子进程收到的数据是',conn.recv())
    conn.send({'name':'alex'})
    print('子进程的Pipe ID是：',id(conn))
    conn.close()
    
if __name__ == '__main__':
    parent_conn,son_conn = multiprocessing.Pipe()       ##  创建双向管道对象
    p = multiprocessing.Process(target=son,args=(son_conn,))
    p.start()
    parent_conn.send('hello son')
    print('主进程收到的数据是：',parent_conn.recv())
    print('主进程的Pipe ID是：',id(parent_conn))
    
    # 子进程收到的数据是 hello son
    # 子进程的Pipe ID是： 44101248
    # 主进程收到的数据是： {'name': 'alex'}
    # 主进程的Pipe ID是： 39919288

管道通信也是资源拷贝的过程，并不是数据共享

（3）Manager（数据共享）

上面两个都不能做到数据共享，只有Manager可以做到数据共享

types list, dict, Namespace, Lock, RLock, Semaphore, BoundedSemaphore, Condition, Event, Barrier, Queue, Value and Array. 这些都可以共享

from multiprocessing import Manager,Process
def son(num,d,l):
    d[num] = '2'
    d['2'] = 2
    l.append(num)

if __name__ == '__main__':

    with Manager() as manager:         ##  创建方式
        d = manager.dict()     ##  创建一个Manager类字典
        l = manager.list(range(5))     ##  创建一个Manager类列表
        p_list = []
        for i in range(10):
            p = Process(target=son,args=(i,d,l))
            p.start()
            p_list.append(p)
        for j in p_list:
            j.join()
        print('共享之后的字典是：',d)
        print('共享之后的列表是：',l)
        # 共享之后的字典是： {3: '2', '2': 2, 2: '2', 1: '2', 0: '2', 5: '2', 6: '2', 4: '2', 7: '2', 9: '2', 8: '2'}
        # 共享之后的列表是： [0, 1, 2, 3, 4, 3, 2, 1, 0, 5, 6, 4, 7, 9, 8]

• 十四、进程同步锁

from multiprocessing import Process,Lock
import time

def foo(l,num):

    with l:
        time.sleep(0.5)
    ##  l.acquire()
        print('hello %d'%num)
    ##  l.release()
if __name__ == '__main__':

    lock = Lock()

    for num in range(10):

        p = Process(target=foo,args=(lock,num,))
        p.start()

运行结果：

 可以看出来，虽然进程之间数据是独立的，但是还是会共享资源，如屏幕等等，上面就出现了抢占资源的情况，所以还是要加一把同步锁防止乱序

有两种方式加锁：

（1）with lock：

（2）lock.acquire（）

　　 lock.release（）

from multiprocessing import Process,Lock
import time

def foo(l,num):

    with l:     ##  第一种方式
        time.sleep(0.5)
     # l.acquire()        ##  第二种方式
        print('hello %d'%num)
     # l.release()
if __name__ == '__main__':

    lock = Lock()

    for num in range(10):

        p = Process(target=foo,args=(lock,num,))
        p.start()

• 十五、进程池

模拟一个场景：有一百块砖需要搬，假如搬一块砖需要1秒钟，最坏的情况是一个人去搬，搬一百秒，但是效率太低了。最理想的情况是一百个人去搬，1秒搬完，这样子开销又太大了

　　　　　　　　现在就用一个折中的办法，开一个池子（容量是五），五个人去搬，搬走一块池子就加一块，这样20秒就能搬完，这就是进程池的概念

from multiprocessing import Pool
import time
def foo(num):
    time.sleep(1)
    print('进程%s运行'%num)

if __name__ == '__main__':
    pool = Pool(5)      ##  运行同时5个进程运行
    for i in range(100):
        # p = pool.apply(func=foo,args=(i,))        ##  同步接口，只允许一个进程走
        p = pool.apply_async(func=foo,args=(i,))
    pool.close()        ##  这两个顺序是固定的
    pool.join()

回调函数

每次执行子进程都会调用一次回调函数，回调函数是在主进程中运行，必须一个参数，接收的参数是子进程的返回值，通常用在logger中

from multiprocessing import Pool
import time,os
def foo(num):
    time.sleep(1)
    print('进程%s运行'%num)
    print('子进程的pid：',os.getpid())
    return 'hello %s'%num

def back(arg):
    print('back:',os.getpid())
    print(arg)

    
if __name__ == '__main__':
    print('主进程的pid：',os.getpid())
    pool = Pool(5)
    for i in range(100):
        p = pool.apply_async(func=foo,args=(i,),callback=back)      ## callback 回调函数
                                                                    ##  每次执行一个子进程，就会调用一次pid ，回调函数是在主进程运行

    pool.close()
    pool.join()

十六、协程（重点）

1、生成器

可以调用__next__（）或者next（）方法的就是一个生成器，生成器函数有一个重要的方法，yield

def foo():
    print('第一次运行')
    yield 2
    print('第二次运行')
    y = yield 3
    print(y)
    
f = foo()
print(f)        ##  <generator object foo at 0x00000000021155E8>    生成器对象

yield有两种调用方法：next 和 send

def foo():
    print('第一次运行')
    yield 2     ##  第一次保持状态     ##  第一次next走到这里
    print('第二次运行')
    y = yield 3    ##   第二次保持状态     ##  第二次next走到这里
    print(y)

f = foo()
print(f)        ##  <generator object foo at 0x00000000021155E8>    生成器对象
print(next(f))         ##  第一次运行    2
f.__next__()            ##  第二次运行

def foo():
    print('第一次运行')
    s = yield 2     ##  第一次保持状态     ##  第一次send走到这里
    print('s的值是',s)
    print('第二次运行')
    y = yield 3    ##   第二次保持状态     ##  第二次send走到这里
    print(y)

f = foo()
next(f)     ##  第一次运行
f.send(5)       ##  注意，这里send是将5传给上一次保持的状态的值
# 第一次运行
# s的值是 5
# 第二次运行

2、协程-----------非抢占式程序

协程，又称微线程，纤程。英文名Coroutine。协程本质上就是一个线程

优点1: 协程极高的执行效率，没有切换的消耗。因为子程序切换不是线程切换，而是由程序自身控制，因此，没有线程切换的开销，和多线程比，线程数量越多，协程的性能优势就越明显。

优点2: 不需要多线程的锁机制，因为只有一个线程，也不存在同时写变量冲突，在协程中控制共享资源不加锁，只需要判断状态就好了，所以执行效率比多线程高很多。

因为协程是一个线程执行，那怎么利用多核CPU呢？最简单的方法是多进程+协程，既充分利用多核，又充分发挥协程的高效率，可获得极高的性能。

import time

def Custommer(name):
    print('ready to eat baozi...')
    while 1:
        new_baozi = yield
        print('[%s] is eating baozi %s'%(name,new_baozi))
        time.sleep(1)

def Producer():
    r = con1.__next__()
    r = con2.__next__()
    n = 0
    while 1:
        print('produce is making baozi[%s] and baozi[%s]'%(n,n+1))
        con1.send(n)
        con2.send(n+1)
        n += 2
        time.sleep(1)


con1 = Custommer('con1')
con2 = Custommer('con2')
Producer()

3、greenlet模块

from greenlet import greenlet
def test1():
    print(12)
    gr2.switch()
    print(56)

def test2():
    print(34)
    gr1.switch()
    print(78)
    gr1.switch()

gr1 = greenlet(test1)
gr2 = greenlet(test2)
gr2.switch()
# 34
# 12
# 78
# 56

 

用户根据自己需求切换，切换顺序图：

缺点：用户需要根据每个IO阻塞进行切换，不太现实

4、gevent

import gevent
import requests,time
start=time.time()
def f(url):
    print('GET: %s' % url)
    resp =requests.get(url)
    data = resp.text
    print('%d bytes received from %s.' % (len(data), url))

# f('https://www.python.org/')      ##  串行
# f('https://www.yahoo.com/')
# f('https://www.baidu.com/')
# f('https://www.sina.com.cn/')
# f("http://www.xiaohuar.com/hua/")

gevent.joinall([
        gevent.spawn(f, 'https://www.python.org/'),         ##  协程
        gevent.spawn(f, 'https://www.yahoo.com/'),
        gevent.spawn(f, 'https://www.baidu.com/'),
        gevent.spawn(f, 'https://www.sina.com.cn/'),
        gevent.spawn(f, 'http://www.xiaohuar.com/hua/'),
])


print("cost time:",time.time()-start)