进程、线程、协程的区别

GIL（全局解释性锁）：

无论启多少个线程，有多少个cpu，Python在执行的时候会在同一时刻只允许一个线程运行。

一个线程需要执行任务，必须获取GIL。

好处：直接杜绝了多个线程访问内存空间的安全问题。

坏处：Python的多线程不是真正多线程，不能充分利用多核CPU的资源。

线程锁（互斥锁）：

线程锁保证同一时刻只有一个线程修改内存空间的同一数据，GIL保证同一时刻只有一个线程在运行。

多线程同时修改同一数据，可能会导致数据不准确既线程不安全。

进程：

系统资源分配的最小单位，需要自己独立的内存空间，进程间数据不共享，开销大，效率低。

可以实现并行（进程数小于CPU数的情况下）和并发。

稳定性好，一个子进程崩溃不会影响其他进程。

若进程过多，操作系统调度会出现问题。

适合密集CPU计算业务。

线程：

依赖进程存在，多个线程之间数据共享、全局变量共享，相对进程效率更高。

因为GIL的存在，在同一进程里只能实现并发。

如果需要保证线程安全，需要加锁控制（锁会降低效率）。

相对进程效率高，适合IO密集型的多任务操作。

协程：

又称微线程，拥有自己的寄存器上下文和栈，协程调度切换时，将寄存器上下文和栈保存到其他地方，在切回来的时候，恢复先前保存的寄存器上下文和栈，直接操作栈几乎没有内核的切换开销。

可以不加锁访问全局变量。

数量上可以是无限个，和多线程比，线程数量越多，协程的性能优势就越明显。

不需要原子操作锁定及同步的开销。

高并发、高扩展性、低成本、效率高。

处理网络I/O性能比较高。

处理CPU计算密集型的时候，性能较低。

本质是单线程，不能同时利用CPU多核，需要和进程配合才能运行在多CPU上，只能实现并发。

打个比方来说明进程、线程、协程的问题：

假设有一个操作系统，是单核的，系统上没有其他的程序（保证单进程）运行，有两个线程 A 和 B ，A 和 B 在单独运行时都需要 10 秒来完成自己的任务，而且任务都是运算操作，A B 之间也没有竞争和共享数据的问题。现在 A B 两个线程并行，操作系统会不停的在 A B 两个线程之间切换，达到一种伪并行的效果，假设切换的频率是每秒一次，切换的成本是 0.1 秒(主要是栈切换)，总共需要 20 + 19 * 0.1 = 21.9 秒。如果使用协程的方式，可以先运行协程 A ，A 结束的时候让位给协程 B ，只发生一次切换，总时间是 20 + 1 * 0.1 = 20.1 秒。如果系统是双核的，那么 A B 两个线程就可以真并行（开启两个进程），总时间只需要 10 秒，而协程的方案仍然需要 20.1 秒。

单线程和多线程的效率问题

在运行程序的过程中，主要是处理网络IO、CPU计算、磁盘IO几种情况。

执行网络IO操作

python解释器在遇到网络IO操作阻塞时会自动释放GIL供其他线程获取。如果是遇到网络IO的操作，因为python解释器会自动释放锁，网络IO过程中本就有些延迟，此时多线程的效率会根据网络延迟情况比单线程高很多。

执行纯计算操作

如果是纯计算的程序，没有网络IO操作，python解释器会每隔100次（次数可以通过sys.setcheckinterval调整）操作释放这把锁。

python在想要执行某个线程的前提是必须拿到GIL这把锁才能进入CPU执行，每次释放GIL，线程进行锁竞争、切换线程，会消耗资源，但python里一个进程永远只能执行一个线程，所以无论CPU的核数是几核，此时python的多线程和单线程相比效率并不高，改成C语言操作此类计算效果会比较好。

使用python创建进程、线程、协程demo

python通过多进程实现多任务demo

方法一：使用multiprocessing模块: 创建Process的实例

import multiprocessing

import time

def task1():

    while True:

        time.sleep(1)

        print("I am task1")

def task2():

    while True:

        time.sleep(2)

        print("I am task2")

if __name__ == '__main__':

    p1 = multiprocessing.Process(target=task1)  # multiprocessing.Process创建了子进程对象p1

    p2 = multiprocessing.Process(target=task2)  # multiprocessing.Process创建了子进程对象p2

    p1.start()  # 子进程p1启动

    p2.start()  # 子进程p2启动

    print("I am main task")  # 这是主进程的任务

方法二：使用进程池Pool

import multiprocessing

import time

def task1():

    while True:

        time.sleep(1)

        print("I am task1")

def task2():

    while True:

        time.sleep(2)

        print("I am task2")

if __name__ == '__main__':

    pool = multiprocessing.Pool(processes=2)  # 创建包含2条进程的进程池，使用池可以有效控制进程池的最大数量

    pool.apply_async(task1)  # 实现异步

    pool.apply_async(task2)

    pool.close()  # 关闭进程池。在调用该方法之后，该进程池不能再接收新任务，它会把当前进程池中的所有任务执行完成后再关闭自己。

    pool.join()  # 等待所有进程完成。

python通过多线程实现多任务demo

import threading

from time import sleep

def task1():  # 线程函数1

    for i in range(0, 9):

        print("I am task1")

def task2():  # 线程函数2

    print('I am task2')

    sleep(1)

t1 = threading.Thread(target=task1)  # 线程一

t2 = threading.Thread(target=task2)  # 线程二

t1.start()  # 开始线程一

# t1.join() # 线程等待，程序会停留在这里，等线程一执行完之后再继续执行下面的代码。

t2.start()  # 开始线程二

python通过协程实现多任务demo

方法一：使用gevent创建协程

import gevent

from gevent import monkey

import time

import random

# 有耗时操作时需要

monkey.patch_all()  # 将程序中用到的耗时操作代码，换为 gevent 中自己实现的模块

def task1():

    for i in range(10):

        print('I am task1', i)

        time.sleep(random.random())

def task2():

    for i in range(10):

        print('I am task2', i)

        time.sleep(random.random())

gevent.joinall([            # 将协程任务添加到事件循环，接收一个任务列表

    gevent.spawn(task1),    # 创建一个普通的执行单元对象并切换

    gevent.spawn(task2)

])

# 等价于

'''

g1 = gevent.spawn(work, 'work1')

g2 = gevent.spawn(work, 'work2')

g1.join()

g2.join()

'''

方法二：使用asyncio创建协程

import asyncio

@asyncio.coroutine  # 把一个generator（生成器）标记为coroutine类型，然后把这个coroutine扔到EventLoop中执行。

def task1():

    for i in range(10):

        yield from asyncio.sleep(1)  # yield from 调用另外一个generator 然后sleep 1秒，模拟IO延迟

        print('I am task1')

@asyncio.coroutine

def task2():

    for i in range(10):

        yield from asyncio.sleep(1)

        print('I am task2')

loop = asyncio.get_event_loop()  # 获取EventLoop，相当于一个循环

tasks = [task2(), task1()]

function(){ //外汇返佣 http://www.fx61.com/  

loop.run_until_complete(asyncio.wait(tasks))  # 执行EventLoop中的coroutine

loop.close()

python使用多进程和协程结合实现多任务demo

from multiprocessing import Pool

import gevent

def task1():

    for i in range(10):

        gevent.sleep(2)

        print('I am task1')

def task2():

    for i in range(10):

        gevent.sleep(2)

        print('I am task2')

def coroutine():

    gevent.joinall([

        gevent.spawn(task1),

        gevent.spawn(task2)

    ])

if __name__ == "__main__":

    p = Pool()  # 不加数字，默认为当前CPU核数

    for i in range(3):

        p.apply_async(coroutine, args=())

    p.close()

    p.join()

进程、线程、协程的区别

GIL（全局解释性锁）：

无论启多少个线程，有多少个cpu，Python在执行的时候会在同一时刻只允许一个线程运行。

一个线程需要执行任务，必须获取GIL。

好处：直接杜绝了多个线程访问内存空间的安全问题。

坏处：Python的多线程不是真正多线程，不能充分利用多核CPU的资源。

线程锁（互斥锁）：

线程锁保证同一时刻只有一个线程修改内存空间的同一数据，GIL保证同一时刻只有一个线程在运行。

多线程同时修改同一数据，可能会导致数据不准确既线程不安全。

进程：

系统资源分配的最小单位，需要自己独立的内存空间，进程间数据不共享，开销大，效率低。

可以实现并行（进程数小于CPU数的情况下）和并发。

稳定性好，一个子进程崩溃不会影响其他进程。

若进程过多，操作系统调度会出现问题。

适合密集CPU计算业务。

线程：

依赖进程存在，多个线程之间数据共享、全局变量共享，相对进程效率更高。

因为GIL的存在，在同一进程里只能实现并发。

如果需要保证线程安全，需要加锁控制（锁会降低效率）。

相对进程效率高，适合IO密集型的多任务操作。

协程：

又称微线程，拥有自己的寄存器上下文和栈，协程调度切换时，将寄存器上下文和栈保存到其他地方，在切回来的时候，恢复先前保存的寄存器上下文和栈，直接操作栈几乎没有内核的切换开销。

可以不加锁访问全局变量。

数量上可以是无限个，和多线程比，线程数量越多，协程的性能优势就越明显。

不需要原子操作锁定及同步的开销。

高并发、高扩展性、低成本、效率高。

处理网络I/O性能比较高。

处理CPU计算密集型的时候，性能较低。

本质是单线程，不能同时利用CPU多核，需要和进程配合才能运行在多CPU上，只能实现并发。

打个比方来说明进程、线程、协程的问题：

假设有一个操作系统，是单核的，系统上没有其他的程序（保证单进程）运行，有两个线程 A 和 B ，A 和 B 在单独运行时都需要 10 秒来完成自己的任务，而且任务都是运算操作，A B 之间也没有竞争和共享数据的问题。现在 A B 两个线程并行，操作系统会不停的在 A B 两个线程之间切换，达到一种伪并行的效果，假设切换的频率是每秒一次，切换的成本是 0.1 秒(主要是栈切换)，总共需要 20 + 19 * 0.1 = 21.9 秒。如果使用协程的方式，可以先运行协程 A ，A 结束的时候让位给协程 B ，只发生一次切换，总时间是 20 + 1 * 0.1 = 20.1 秒。如果系统是双核的，那么 A B 两个线程就可以真并行（开启两个进程），总时间只需要 10 秒，而协程的方案仍然需要 20.1 秒。

单线程和多线程的效率问题

在运行程序的过程中，主要是处理网络IO、CPU计算、磁盘IO几种情况。

执行网络IO操作

python解释器在遇到网络IO操作阻塞时会自动释放GIL供其他线程获取。如果是遇到网络IO的操作，因为python解释器会自动释放锁，网络IO过程中本就有些延迟，此时多线程的效率会根据网络延迟情况比单线程高很多。

执行纯计算操作

如果是纯计算的程序，没有网络IO操作，python解释器会每隔100次（次数可以通过sys.setcheckinterval调整）操作释放这把锁。

python在想要执行某个线程的前提是必须拿到GIL这把锁才能进入CPU执行，每次释放GIL，线程进行锁竞争、切换线程，会消耗资源，但python里一个进程永远只能执行一个线程，所以无论CPU的核数是几核，此时python的多线程和单线程相比效率并不高，改成C语言操作此类计算效果会比较好。

使用python创建进程、线程、协程demo

python通过多进程实现多任务demo

方法一：使用multiprocessing模块: 创建Process的实例

import multiprocessing

import time

def task1():

    while True:

        time.sleep(1)

        print("I am task1")

def task2():

    while True:

        time.sleep(2)

        print("I am task2")

if __name__ == '__main__':

    p1 = multiprocessing.Process(target=task1)  # multiprocessing.Process创建了子进程对象p1

    p2 = multiprocessing.Process(target=task2)  # multiprocessing.Process创建了子进程对象p2

    p1.start()  # 子进程p1启动

    p2.start()  # 子进程p2启动

    print("I am main task")  # 这是主进程的任务

方法二：使用进程池Pool

import multiprocessing

import time

def task1():

    while True:

        time.sleep(1)

        print("I am task1")

def task2():

    while True:

        time.sleep(2)

        print("I am task2")

if __name__ == '__main__':

    pool = multiprocessing.Pool(processes=2)  # 创建包含2条进程的进程池，使用池可以有效控制进程池的最大数量

    pool.apply_async(task1)  # 实现异步

    pool.apply_async(task2)

    pool.close()  # 关闭进程池。在调用该方法之后，该进程池不能再接收新任务，它会把当前进程池中的所有任务执行完成后再关闭自己。

    pool.join()  # 等待所有进程完成。

python通过多线程实现多任务demo

import threading

from time import sleep

def task1():  # 线程函数1

    for i in range(0, 9):

        print("I am task1")

def task2():  # 线程函数2

    print('I am task2')

    sleep(1)

t1 = threading.Thread(target=task1)  # 线程一

t2 = threading.Thread(target=task2)  # 线程二

t1.start()  # 开始线程一

# t1.join() # 线程等待，程序会停留在这里，等线程一执行完之后再继续执行下面的代码。

t2.start()  # 开始线程二

python通过协程实现多任务demo

方法一：使用gevent创建协程

import gevent

from gevent import monkey

import time

import random

# 有耗时操作时需要

monkey.patch_all()  # 将程序中用到的耗时操作代码，换为 gevent 中自己实现的模块

def task1():

    for i in range(10):

        print('I am task1', i)

        time.sleep(random.random())

def task2():

    for i in range(10):

        print('I am task2', i)

        time.sleep(random.random())

gevent.joinall([            # 将协程任务添加到事件循环，接收一个任务列表

    gevent.spawn(task1),    # 创建一个普通的执行单元对象并切换

    gevent.spawn(task2)

])

# 等价于

'''

g1 = gevent.spawn(work, 'work1')

g2 = gevent.spawn(work, 'work2')

g1.join()

g2.join()

'''

方法二：使用asyncio创建协程

import asyncio

@asyncio.coroutine  # 把一个generator（生成器）标记为coroutine类型，然后把这个coroutine扔到EventLoop中执行。

def task1():

    for i in range(10):

        yield from asyncio.sleep(1)  # yield from 调用另外一个generator 然后sleep 1秒，模拟IO延迟

        print('I am task1')

@asyncio.coroutine

def task2():

    for i in range(10):

        yield from asyncio.sleep(1)

        print('I am task2')

loop = asyncio.get_event_loop()  # 获取EventLoop，相当于一个循环

tasks = [task2(), task1()]

function(){ //外汇返佣 http://www.fx61.com/  

loop.run_until_complete(asyncio.wait(tasks))  # 执行EventLoop中的coroutine

loop.close()

python使用多进程和协程结合实现多任务demo

from multiprocessing import Pool

import gevent

def task1():

    for i in range(10):

        gevent.sleep(2)

        print('I am task1')

def task2():

    for i in range(10):

        gevent.sleep(2)

        print('I am task2')

def coroutine():

    gevent.joinall([

        gevent.spawn(task1),

        gevent.spawn(task2)

    ])

if __name__ == "__main__":

    p = Pool()  # 不加数字，默认为当前CPU核数

    for i in range(3):

        p.apply_async(coroutine, args=())

    p.close()

    p.join()