python多进程与协程详解编程语言

1、进程的概念

什么是进程—>CPU在同一时刻只能处理一个任务,只是因为cpu执行速度很快。
cpu在各个任务之间来回的进行切换。
进程的概念：正在进行的一个过程或者说一个任务，而负责执行任务的则是CPU，进程本身是
一个抽象的概念,即进程就是一个过程、一个任务。
CPU描述的是一个程序的执行过程.
进程之间是如何做到并发的：CPU在各个任务之间来回的进行切换，并在切换的过程当中保存当前
进程的执行状态（保存蛋糕的执行过程）。
进程与程序的区别：程序相当于菜谱，而进程相当于做菜的整个过程。
需要强调的是：同一个程序执行两次(双击),那也是两个进程，比如打开暴风影音，虽然都是同一个软件，但是一个可以播放a，一个可以播放b.
核的概念：https://zhidao.baidu.com/question/541410131.html
处理器，就是说有几个处理器。。。也就说一个CPU里面会有几个处理器，这样就可以同时处理几个要求了。。。

2、并行与并发的区别

无论是并行还是并发,在用户看来都是同时运行的，不管是进程还是线程，都只是一个任务而已，
真正干活的是CPU，CPU来做这些任务，而一个cpu（单核）同一时刻只能执行一个任务。
并行：多个任务同时运行，只有具备多个cpu才能实现并行，含有几个cpu，也就意味着在同一时刻可以执行几个任务。
并发：是伪并行，即看起来是同时运行的，实际上是单个CPU在多道程序之间来回的进行切换。

3、同步与异步的概念

同步就是指一个进程在执行某个请求的时候，若该请求需要一段时间才能返回信息，那么这个进程将会一直等待下去，直到收到返回信息才继续执行下去。
异步是指进程不需要一直等下去，而是继续执行下面的操作，不管其他进程的状态。当有消息返回时系统会通知进行处理，这样可以提高执行的效率。
打电话的过程就是同步通信，发短信时就是异步通信。

4、进程创建的方式

用户创建出来的所有进程都是由操作系统负责的，因此无论是哪一种创建进程的方式，实际上都是调用操作系统的接口创建的,进程的切换都是由操作系统控制的。
无论哪一种创建进程的方式，新进程的创建都是由一个已经存在的进程执行了一个用于创建进程的系统调用而创建的。

5、父进程和子进程之间的关系

子进程创建后，父进程和子进程有各自不同的地址空间，多道技术要求物理层面实现进程之间内存的
隔离，任何一个进程在其地址空间的修改都不会影响到另外一个进程。
注意：子进程和父进程之间是可以有只读的共享的内存区域的。
进程与进程之间数据（资源）是隔离的，两个进程之间可以基于管道这种方式进行通信。在Unix当中，是含有进程层次的概念的，但是在windows当中，是没有进程层次的概念的，所有的进程都是地位相同的。
在Linux当中，每启动一个命令，都会启动一个进程。

6、线程的概念

一个进程里面至少有一个控制线程，进程的概念只是一种抽象的概念，真正在CPU上面调度的是进程
里面的线程,就好比真正在地铁这个进程里面工作的实际上是地铁里面的线程,北京地铁里面至少要有
一个线程，线程是真正干活的，线程用的是进程里面包含的一堆资源,线程仅仅是一个调度单位，不包含资源。

7、 什么时候需要开启多个线程？

什么时候需要开启多个线程：一个进程里面的多个线程共享这个进程里面的资源，因此如果多个任务共享同一块资源的时候，需要开启多个线程。
多线程指的是，在一个进程中开启多个线程，简单的说：如果多个任务共用同一个资源空间，那么必须在一个进程内开启多个线程。

8、一个进程里面需要包含多个线程？

一个进程这个任务里面可能对应多个分任务，如果一个进程里面只开启一个线程的话，多个分任务之间实际上是串行的执行效果，即一个程序里面只含有一条执行路径。

9、多线程和多进程的关系

对于计算密集型应用，应该使用多进程;对于IO密集型应用，应该使用多线程。
线程的创建比进程的创建开销小的多。

''' 
about what 
''' 
import multiprocessing 
 
import time 
 
 
def func(arg): 
    pname = multiprocessing.current_process().name 
    pid = multiprocessing.current_process().pid 
    print("当前进程ID=%d,name=%s" % (pid, pname)) 
 
    for i in range(5): 
        print(arg) 
        time.sleep(1) 
         
if __name__ == "__main__": 
    pname = multiprocessing.current_process().name 
    pid = multiprocessing.current_process().pid 
    print("当前进程ID=%d,name=%s" % (pid, pname)) 
 
    p = multiprocessing.Process(target=func, args=("hello",)) 
    # p = multiprocessing.Process(target=func,name="劳资的队伍",args=("hello",)) 
    p.daemon = True  # 设为【守护进程】（随主进程的结束而结束） 
    p.start() 
 
    while True: 
        print("子进程是否活着？", p.is_alive()) 
        time.sleep(1) 
 
    print("main over")

协程

协程，又称微线程，纤程。英文名Coroutine。

协程是啥 ？？

首先我们得知道协程是啥？协程其实可以认为是比线程更小的执行单元。为啥说他是一个执行单元，因为他自带CPU上下文。这样只要在合适的时机，我们可以把一个协程切换到另一个协程,只要这个过程中保存或恢复 CPU上下文那么程序还是可以运行的。

通俗的理解：在一个线程中的某个函数，可以在任何地方保存当前函数的一些临时变量等信息，然后切换到另外一个函数中执行，注意不是通过调用函数的方式做到的，并且切换的次数以及什么时候再切换到原来的函数都由开发者自己确定。

协程和线程差异

最大的优势就是协程极高的执行效率,因为子程序切换不是线程切换，而是由程序自身控制，因此，没有线程切换的开销线程切换从系统层面远不止保存和恢复 CPU上下文这么简单。操作系统为了程序运行的高效性每个线程都有自己缓存Cache等等数据，操作系统还会帮你做这些数据的恢复操作。所以线程的切换非常耗性能。但是协程的切换只是单纯的操作CPU的上下文，所以一秒钟切换个上百万次系统都抗的住。

第二大优势就是不需要多线程的锁机制，因为只有一个线程，也不存在同时写变量冲突。

2、使用协程

1.使用greenlet + switch实现协程调度

''' 
使用greenlet + switch实现协程调度 
''' 
from greenlet import greenlet 
 
import time 
 
def func1(): 
    print("开门走进卫生间") 
    time.sleep(3) 
    gr2.switch()  # 把CPU执行权交给gr2 
 
    print("飞流直下三千尺") 
    time.sleep(3) 
    gr2.switch() 
    pass 
 
def func2(): 
    print("一看拖把放旁边") 
    time.sleep(3) 
    gr1.switch() 
 
    print("疑是银河落九天") 
    pass 
 
if __name__ == '__main__': 
    gr1 = greenlet(func1) 
    gr2 = greenlet(func2) 
    gr1.switch()  # 把CPU执行权先给gr1 
    pass 

2.使用gevent +　sleep自动将CPU执行权分配给当前未睡眠的协程

''' 
使用gevent +　sleep自动将CPU执行权分配给当前未睡眠的协程 
''' 
import gevent 
 
def func1(): 
    gevent.sleep(1) 
    print("大梦谁先觉") 
 
    gevent.sleep(13) 
    print("1:over") 
    pass 
 
def func2(): 
    gevent.sleep(3) 
    print("平生我自知") 
 
    gevent.sleep(9) 
    print("2:over") 
    pass 
 
def func3(): 
    gevent.sleep(5) 
    print("草堂春睡足") 
 
    gevent.sleep(5) 
    print("3:over") 
    pass 
 
def func4(): 
    gevent.sleep(7) 
    print("窗外日迟迟") 
 
    gevent.sleep(1) 
    print("4:over") 
     
def simpleGevent(): 
    gr1 = gevent.spawn(func1) 
    gr2 = gevent.spawn(func2) 
    gr3 = gevent.spawn(func3) 
    gr4 = gevent.spawn(func4) 
    gevent.joinall([ 
        gr1, gr2, gr3, gr4 
    ]) 
 
if __name__ == '__main__': 
    # simpleGevent() 
    pass 

3.通过monkey调度

''' 
使用gevent +　monkey.patch_all()自动调度网络IO协程 
''' 
import gevent 
import requests 
import time 
from gevent import monkey 
 
def getPageText(url, order=0): 
    print("No%d:%s请求开始..." % (order, url)) 
    resp = requests.get(url)  # 发起网络请求，返回需要时间——阻塞IO 
 
    html = resp.text 
    print("No%d:%s成功返回：长度为%d" % (order, url, len(html))) 
 
# 将【标准库-阻塞IO实现】替换为【gevent-非阻塞IO实现】 
monkey.patch_all() 
if __name__ == '__main__': 
    start = time.time() 
    time.clock() 
    gevent.joinall([ 
        gevent.spawn(getPageText, "http://www.sina.com", order=1), 
        gevent.spawn(getPageText, "http://www.qq.com", order=2), 
        gevent.spawn(getPageText, "http://www.baidu.com", order=3), 
        gevent.spawn(getPageText, "http://www.163.com", order=4), 
        gevent.spawn(getPageText, "http://www.4399.com", order=5), 
        gevent.spawn(getPageText, "http://www.sohu.com", order=6), 
        gevent.spawn(getPageText, "http://www.youku.com", order=7), 
        gevent.spawn(getPageText, "http://www.iqiyi.com", order=8), 
    ]) 
 
    end = time.time() 
    print("over，耗时%d秒" % (end - start)) 
    print(time.clock()) 
    pass