python——多线程，多进程，协程

线程，进程

定义：

进程: 是对各种资源管理的集合，qq 要以一个整体的形式暴露给操作系统管理，里面包含对各种资源的调用，内存的管理，网络接口的调用等

线程: 是操作系统最小的调度单位， 是一串指令的集合。

进程要想操作CPU，就必须要创建一个线程（进程中至少包含一个线程）

区别：

1.线程共享内存空间（共享数据等），进程的内存空间是独立的

2.同一进程的线程之间可以相互交流 ，2个进程之间的交流必须通过一个中间代理

3.线程可以操作和控制其他线程（同一进程下），进程只能操作和控制子进程。

对主线程的更改可能会影响到其他线程的工作，对父进程的更改（除非关闭）不会影响子进程。（子进程还可以派生子进程）

Python中的多线程 

import threading

def run(n):
  print('运行线程',n)

for i in range(10):     # 创建10个线程
    t = threading.Thread(target=run, args=(i,))    # 线程运行的函数和参数
    t.setDaemon(True)   # 设置为守护线程（在主线程线程结束后自动退出，默认为False即主线程线程结束后子线程仍在执行）
    t.start()   # 启动线程

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

更多方法：

• start            线程准备就绪，等待CPU调度
• setName      为线程设置名称
• getName      获取线程名称
• setDaemon   设置为后台线程或前台线程（默认）
                       如果是后台线程，主线程执行过程中，后台线程也在进行，主线程执行完毕后，后台线程不论成功与否，均停止
                       如果是前台线程，主线程执行过程中，前台线程也在进行，主线程执行完毕后，等待前台线程也执行完成后，程序停止
• join              逐个执行每个线程，执行完毕后继续往下执行，该方法使得多线程变得无意义
• run              线程被cpu调度后自动执行线程对象的run方法

互斥锁（Lock、RLock）

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

import threading
import time

gl_num = 0

lock = threading.RLock()    # 定义线程锁


def Func():
    lock.acquire()      # 开始锁
    global gl_num
    gl_num += 1
    time.sleep(1)
    print(gl_num)
    lock.release()      # 结束锁


for i in range(10):
    t = threading.Thread(target=Func)
    t.start()
    
"""
没有锁的时候打印:
>> 10,10,10,10,10,10,10,10,10,10

有锁的时候打印:
>> 1,2,3,4,5,6,7,8,9,10
"""

信号量（Semaphore）

互斥锁同时只允许一个线程更改数据，而信号量锁是同时允许一定数量的线程更改数据 ，多个线程同时执行完毕。

import threading, time


def run(n):
    semaphore.acquire()     # 信号量锁开始
    time.sleep(1)
    print("当前运行线程为: %s" % n)
    semaphore.release()     # 结束


if __name__ == '__main__':

    num = 0
    semaphore = threading.BoundedSemaphore(5)    # 最多允许5个线程同时运行(5个5个一起出来)
    for i in range(20):
        t = threading.Thread(target=run, args=(i,))
        t.start()

事件（event）

python线程的事件用于主线程控制其他线程的执行，事件主要提供了两个方法：event.set()设定，event.clear()没设定。

• event.wait()：等待设定
• event.is_set()：判断是否设定

import time,threading

event = threading.Event()

def lighter():
    count=0
    event.set()     #设定
    while True:
        if count<10 and count>=5:
            event.clear()   #清除设定
            print("33[41;1m红灯33[0m")
            time.sleep(1)
        elif count>10:
            count=0
            event.set()
        else:
            print("33[42;1m绿灯33[0m")
            time.sleep(1)
        count+=1

def car(name):
    while True:
        if event.is_set():  #判断是否设定
            print("33[32;1m[%s] run...33[0m"%name)
            time.sleep(1)
        else:
            print('33[31;1m [%s] stop...'%name)
            event.wait()    #等待设定
            print('33[33;1m [%s]走咯'%name)


light=threading.Thread(target=lighter,)

light.start()

car1=threading.Thread(target=car,args=('Tesla',))

car1.start()

Python中的多进程 

多进程特点：

• 每一个进程都是由父进程启动的
• 子进程被父进程启动后就是独立的（父进程copy了一份给子进程）

from multiprocessing import Process

def foo(i):
    print('say hi', i)

if __name__ == '__main__':
    for i in range(10):
        p = Process(target=foo, args=(i,))
        p.start()

获取进程id：

from multiprocessing import Process     #多进程
import os

def info(title):
    print(title)
    print('module name:', __name__)
    print('parent process:', os.getppid())  #获取父进程的端口号
    print('process id:', os.getpid())   #获取当前进程的端口号
    print('
')

def f(name):
    info('33[31;1mcalled from child process function f33[0m')
    print('hello', name)

if __name__ == '__main__':
    info('33[32;1mmain process line33[0m')
    p = Process(target=f, args=('bob',))
    p.start()
    p.join()

get进程id

进程数据共享

• 进程各自持有一份数据，默认无法共享数据
•  当创建进程时（非使用时），共享数据会被拿到子进程中，当进程中执行完毕后，再赋值给原值。

通过队列共享数据：

from multiprocessing import Process, Queue

def run(qq):
    qq.put("123")


if __name__=='__main__':
    q=Queue()    #生成一个队列，通过队列进行传递数据
    p=Process(target=run,args=(q,))
    p.start()
    print(q.get())
    p.join()

通过字典共享数据：

from multiprocessing import Process, Manager
import os
def f(d, l):
    d[os.getpid()] =os.getpid()
    l.append(os.getpid())
    print(l)

if __name__ == '__main__':
    with Manager() as manager:  #Manager()=manager
        d = manager.dict() #{} #生成一个字典，可在多个进程间共享和传递

        l = manager.list(range(5))#生成一个列表，可在多个进程间共享和传递
        p_list = []
        for i in range(10):
            p = Process(target=f, args=(d, l))
            p.start()
            p_list.append(p)
        for res in p_list: #等待结果
            res.join()

        print(d)
        print(l)

进程锁：

在多个进程共享一个屏幕时可能会导致输出的数据变乱。

from multiprocessing import Process, Lock

def f(l, i):
    l.acquire()     #设置进程锁
    try:
        print('hello world', i)
    finally:
        l.release()     #取消进程锁

if __name__ == '__main__':
    l = Lock()  #实例化锁
    for num in range(10):
        Process(target=f, args=(l, num)).start()

进程池：

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

进程池中有两个方法：

• apply：串行
• apply_async：并行

from  multiprocessing import Pool
import time
import os

def Foo(i):
    time.sleep(2)
    print("in process",os.getpid())
    return i + 100

def Bar(arg):
    print('-->exec done:', arg,os.getpid())

if __name__ == '__main__':
    #freeze_support()
    pool = Pool(processes=3) #允许进程池同时放入5个进程
    print("主进程",os.getpid())
    for i in range(10):
        pool.apply_async(func=Foo, args=(i,), callback=Bar) #callback=回调
        #pool.apply(func=Foo, args=(i,)) #串行
        #pool.apply_async(func=Foo, args=(i,)) #并行
    print('end')
    pool.close()
    pool.join() #进程池中进程执行完毕后再关闭，如果注释，那么程序直接关闭。.join()

协程（微线程）

通过单线程实现并发（协程只有一个线程，so不用锁）

协程的好处：

• 无需线程上下文切换的开销
• 无需原子操作锁定及同步的开销
• "原子操作(atomic operation)是不需要synchronized"，所谓原子操作是指不会被线程调度机制打断的操作；这种操作一旦开始，就一直运行到结束，中间不会有任何 context switch （切换到另一个线程）。原子操作可以是一个步骤，也可以是多个操作步骤，但是其顺序是不可以被打乱，或者切割掉只执行部分。视作整体是原子性的核心。
• 方便切换控制流，简化编程模型
• 高并发+高扩展性+低成本：一个CPU支持上万的协程都不是问题。所以很适合用于高并发处理。

缺点：

• 无法利用多核资源：协程的本质是个单线程,它不能同时将 单个CPU 的多个核用上,协程需要和进程配合才能运行在多CPU上.当然我们日常所编写的绝大部分应用都没有这个必要，除非是cpu密集型应用。
• 进行阻塞（Blocking）操作（如IO时）会阻塞掉整个程序

使用yield实现协程操作例子

import time

def consumer(name):
    print("--->starting eating baozi...")
    while True:
        new_baozi = yield
        print("[%s] is eating baozi %s" % (name, new_baozi))
        # time.sleep(1)

def producer():
    r = con.__next__()
    r = con2.__next__()
    n = 0
    while n < 5:
        n += 1
        con.send(n)
        con2.send(n)
        time.sleep(1)
        print("33[32;1m[producer]33[0m is making baozi %s" % n)

if __name__ == '__main__':
    con = consumer("c1")
    con2 = consumer("c2")
    p = producer()

yield

同步与异步性能差别

import gevent

def task(pid):
    gevent.sleep(0.5)
    print('Task %s done' % pid)

def synchronous():  #每个都要等0.5s，需要5s
    for i in range(1, 10):
        task(i)

def asynchronous():  #一共等0.5s
    threads = [gevent.spawn(task, i) for i in range(10)]
    gevent.joinall(threads)

print('Synchronous:')
synchronous()

print('Asynchronous:')
asynchronous()

同步与异步

总结：

1、多进程，多线程，协程

操作系统方面的多进程，多线程，协程：

操作系统可以开多个进程，一个进程可以有多个线程，多个线程可以被分配到不同的核心上跑，但实际上每个核心上只有一个线程，只是这个线程在不停的进行上下文的切换，给我们一种并发的感觉。

协程：单线程的调度机制。它的作用是让原来要使用异步+回调方式（调用线程）写的非人类代码,可以用看似同步的方式写出来。协程是先出现的，但它有明显的时间差，没有并发的感觉，所以出现了线程。

python的多进程，多线程，协程：

但python的多线程只能在一个核心上跑（创始人没想到会有多核出现），就是单核的上下文切换，所以很鸡肋。于是协程在python大展拳脚，好多框架都是使用协程来解决多任务的，而不是线程（scrapy，tornado）。

python中多进程，多线程，协程的使用：

IO密集型：多线程/协程（可以用异步），cpu占用率低，单个cpu核心就够了

CPU密集型：多进程，多给它几个核心提升性能

2、python多线程不用join，进程需要（否则子进程会在进程结束时强制被关闭）

1 python 默认参数创建线程后，不管主线程是否执行完毕，都会等待子线程执行完毕才一起退出，有无join结果一样

2 如果创建线程，并且设置了daemon为true，即thread.setDaemon(True), 则主线程执行完毕后自动退出，不会等待子线程的执行结果。而且随着主线程退出，子线程也消亡。

3 join方法的作用是阻塞，等待子线程结束，join方法有一个参数是timeout，即如果主线程等待timeout，子线程还没有结束，则主线程强制结束子线程。

4 如果线程daemon属性为False， 则join里的timeout参数无效。主线程会一直等待子线程结束。

5 如果线程daemon属性为True， 则join里的timeout参数是有效的， 主线程会等待timeout时间后，结束子线程。此处有一个坑，即如果同时有N个子线程join(timeout），那么实际上主线程会等待的超时时间最长为 N ＊ timeout， 因为每个子线程的超时开始时刻是上一个子线程超时结束的时刻。