进程，线程，协程

一、进程

　　定义：

　　　　一个运行起来的程序就是一个进程。进程是资源分配的最小单位（ 内存、cpu、网络、io）。进程具有独立的内存空间，所以没有办法相互通信。

　　进程间如何通信：

　　　　进程queue(父子进程通信)
　　　　pipe（同一程序下两个进程通信）
　　　　managers（同一程序下多个进程通信）
　　　　RabbitMQ、redis等（不同程序间通信）

　　CPU分时

CPU比你的手速快多了，分时处理每个线程，但是由于太快然你觉得每个线程都是独占cpu
cpu是计算，只有时间片到了，获取cpu，线程真正执行
当你想使用 网络、磁盘等资源的时候，需要cpu的调度

　　普通的进程：

import multiprocessing,time
def work():
    for x in range(5):
        print("工作中。。。",(x+1))
        time.sleep(0.5)
if __name__ == '__main__':
    #创建进程
    work_process=multiprocessing.Process(target=work)
    #启动
    work_process.start()

　　进程池：

　　　　为什么需要进程池：

　　　　　　一次性开启指定数量的进程如果有十个进程，有一百个任务，一次可以处理多少个（一次性只能处理十个）防止进程开启数量过多导致服务器压力过大

import multiprocessing,time
def work():
    for x in range(5):
        print("工作中。。。",(x+1))
        time.sleep(0.5)
def dance():
    for x in range(5):
        print("跳舞中。。。",(x+1))
        time.sleep(0.5)
if __name__ == '__main__':
    #创建进程
 　　work_process=multiprocessing.Process(target=work)
13　　  dance_process=multiprocessing.Process(target=dance)
    #启动
    work_process.start()
    #判断进程是否还活着
    print(work_process.is_alive())
    #启动
    dance_process.start()
    #休眠5秒
    time.sleep(5)
    # 判断进程是否还活着
    print(dance_process.is_alive())

　　进程与线程的区别：

1. 线程之间共享全局变量
2. 进程之间不共享全局变量
3. 每开辟一个进程都需要向操作系统索要运行资源，而线程可以共享进程中的资源
4. 多进程开发比单进程多线程开发程序的稳定性强，因为多进程开发，某个进程死了，不会影响程序的运行

二、线程

　　定义：

　　　　线程是操作系统调度的最小单位，线程是进程正真的执行者，是一些指令的集合（进程资源的拥有者），同一个进程下的读多个线程共享内存空间，数据直接访问（数据共享），为了保证数据安全，必须使用线程锁

　　GIL全局解释器锁：

　　　　在python全局解释器下，保证同一时间只有一个线程运行，防止多个线程都修改数据

　　　　GIL锁只能保证同一时间只能有一个线程对某个资源操作，但当上一个线程还未执行完毕时可能就会释放GIL，其他线程就可以操作了　　

　　线程锁（互斥锁）：　　　　

　　　　线程锁本质把线程中的数据加了一把互斥锁加上线程锁之后所有其他线程，读都不能读这个数据

• 有了GIL全局解释器锁为什么还需要线程锁

因为cpu是分时使用的

• 死锁定义

两个以上的进程或线程在执行过程中，因争夺资源而造成的一种互相等待的现象，若无外力作用，它们都将无法推进下去

　　多线程

　　　　1、join ()方法：主线程A中，创建了子线程B，并且在主线程A中调用了B.join()，那么，主线程A会在调用的地方等待，直到子线程B完成操作后，才可以接着往下执行，那么在调用这个线程时可以使用被调用线程的join方法。
　　　　原型：join([timeout])，里面的参数时可选的，代表线程运行的最大时间，即如果超过这个时间，不管这个此线程有没有执行完毕都会被回收，然后主线程或函数都会接着执行的。

　　　　2、setDaemon()方法。主线程A中，创建了子线程B，并且在主线程A中调用了B.setDaemon()，这个的意思是，把主线程A设置为守护线程，这时候，要是主线程A执行结束了，就不管子线程B是否完成，一并和主线程A退出.这就是setDaemon方法的含义，这基本和join是相反的。此外，还有个要特别注意的：必须在start() 方法调用之前设置。

　　线程池：

　　　　系统启动一个新线程的成本是比较高的，因为它涉及与操作系统的交互。在这种情形下，使用线程池可以很好地提升性能，尤其是当程序中需要创建大量生存期很短暂的线程时，更应该考虑使用线程池。线程池在系统启动时即创建大量空闲的线程，程序只要将一个函数提交给线程池，线程池就会启动一个空闲的线程来执行它。当该函数执行结束后，该线程并不会死亡，而是再次返回到线程池中变成空闲状态，等待执行下一个函数。此外，使用线程池可以有效地控制系统中并发线程的数量。当系统中包含有大量的并发线程时，会导致系统性能急剧下降，甚至导致 Python 解释器崩溃，而线程池的最大线程数参数可以控制系统中并发线程的数量不超过此数。

"""线程"""
import threading
import time
def sing(num):
　　for i in range(num):
　　　　print("唱歌中")
　　　　time.sleep(0.5)
def dance(num):
　　for x in range(num):
　　print("跳舞中")
　　time.sleep(0.5)
def show_student_info(name,age,sex):
　　print(name,age,sex)
if __name__ == '__main__':
　　sing_thread=threading.Thread(target=sing,args=(3,))
　　dance_thread=threading.Thread(target=dance,args=(4,))
　　info_thread=threading.Thread(target=show_student_info,kwargs={"name":"张浩","age":"18","sex":"男"})
　　sing_thread.start()
　　dance_thread.start()
　　info_thread.start()
#target:执行目标函数名
#kwargs:已字典的方式去给函数传参
#args：已元组的方式去传参

三、协程

　　定义：

　　　　协程微线程，纤程，本质是一个单线程，协程能在单线程处理高并发

　　　　线程遇到I/O操作会等待、阻塞，协程遇到I/O会自动切换（剩下的只有CPU操作）
　　　　线程的状态保存在CPU的寄存器和栈里而协程拥有自己的空间，所以无需上下文切换的开销，所以快

　　为什么协程能够遇到I/O自动切换：
　　　　协程有一个gevent模块(封装了greenlet模块)，遇到I/O自动切换

　　协程缺点：
　　　　无法利用多核资源：协程的本质是个单线程,它不能同时将 单个CPU 的多个核用上,协程需要和进程配合才能运行在多CPU上

　　　　线程阻塞（Blocking）操作（如IO时）会阻塞掉整个程序

　　协程最大的优点：
　　　　不仅是处理高并发（单线程下处理高并发）
　　　　特别节省资源（500日活，用php写需要两百多态机器，但是golang只需要二十多太机器）

　　协程处理并发：　　　　

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

　　　　gevent每次遇到io操作，需要耗时等待时，会自动跳到下一个协程继续执行。

import gevent

def A():
    while 1:
        print('-------A-------')
        gevent.sleep(1) #用来模拟一个耗时操作，注意不是time模块中的sleep

def B():
    while 1:
        print('-------B-------')
        gevent.sleep(0.5)  #每当碰到耗时操作，会自动跳转至其他协程

g1 = gevent.spawn(A) # 创建一个协程
g2 = gevent.spawn(B)
g1.join()  #等待协程执行结束
g2.join()

　　　　greenlet模块：遇到IO手动切换

from greenlet import greenlet
import time

def A():
    while 1:
        print('-------A-------')
        time.sleep(0.5)
        g2.switch()

def B():
    while 1:
        print('-------B-------')
        time.sleep(0.5)
        g1.switch()

g1 = greenlet(A)  #创建协程g1
g2 = greenlet(B)

g1.switch()  #跳转至协程g1

　　select、poll、epoll：

　　　　I/O的实质是什么？
　　　　　　I/O的实质是将硬盘中的数据，或收到的数据实现从内核态 copy到 用户态的过程

　　　　　　本文讨论的背景是Linux环境下的network IO。
　　　　　　比如微信读取本地硬盘的过程
　　　　　　微信进程会发送一个读取硬盘的请求----》操作系统
　　　　　　只有内核才能够读取硬盘中的数据—》数据返回给微信程序（看上去就好像是微信直接读取）

　　　　用户态 & 内核态
　　　　　　系统空间分为两个部分，一部分是内核态，一部分是用户态的部分
　　　　　　内核态：内核态的空间资源只有操作系统能够访问
　　　　　　用户态：我们写的普通程序使用的空间

　　　　select 在一个进程内可以维持最多 1024 个连接

　　　　poll 在此基础上做了加强，可以维持任意数量的连接。
　　　　epoll 是 select 和 poll 的增强版，epoll 同 poll 一样，文件描述符数量无限制。
　　select

只能处理1024个连接（每一个请求都可以理解为一个连接）
不能告诉用户程序，哪一个连接是活跃的

　　pool

只是取消了最大1024个活跃的限制
不能告诉用户程序，哪一个连接是活跃的

　　epool

　　　　不仅取消了1024这个最大连接限制
　　　　而且能告诉用户程序哪一个是活跃的

　　猴子补丁：

在运行期间动态修改一个类或模块。

class A:
    def func(self):
        print("Hi")
def monkey(self):
    print("Hi, monkey")
m.A.func = monkey
a = m.A()
a.func()