并发编程概述

Posted 2021-02-19 cou1d

进程理论

进程：程序运行的一个过程

并发：是伪并行，即看起来是同时运行。单个cpu+多道技术就可以实现并发

并行：同时运行，只有具备多个cpu才能实现并行

单核下的多道技术：有四个核，六个任务，这样同一时间有四个任务被执行，假设分别被分配给了cpu1，cpu2，cpu3，cpu4,一旦任务1遇到I/O就被迫中断执行，此时任务5就拿到cpu1的时间片去执行，这就是单核下的多道技术。

并发编程多进程代码：

multiprocessing模块：开启子进程，并在子进程中执行我们定制的任务（比如函数）

Process()

from multiprocessing import Process
def piao(name):
    print(‘%s piaoing‘ %name)
    time.sleep(random.randrange(1,5))
    print(‘%s piao end‘ %name)
if __name__ == ‘__main__‘:
    #实例化得到四个对象
    p1=Process(target=piao,args=(‘egon‘,)) #必须加,号
    p2=Process(target=piao,args=(‘alex‘,))
    p3=Process(target=piao,args=(‘wupeqi‘,))
    p4=Process(target=piao,args=(‘yuanhao‘,))
    #调用对象下的方法，开启四个进程
    p1.start()
    p2.start()
    p3.start()
    p4.start()
    print(‘主‘)

Lock()-->互斥锁：

#由并发变成了串行,牺牲了运行效率,但避免了竞争
from multiprocessing import Process,Lock
import os,time
def work(lock):
    lock.acquire() #加锁
    print(‘%s is running‘ %os.getpid())
    time.sleep(2)
    print(‘%s is done‘ %os.getpid())
    lock.release() #释放锁
if __name__ == ‘__main__‘:
    lock=Lock()
    for i in range(3):
        p=Process(target=work,args=(lock,))
        p.start()

Queue()---》队列

守护进程

线程

概念：每个进程有一个地址空间，而且默认就有一个控制线程。一个进程内可以有多个线程.

例如：车间--》进程；车间内的制造各种产品流水线--》线程

特点：

1. 同一个进程内的多个线程共享该进程内的地址资源

2. ###### 创建线程的开销要远小于创建进程的开销（创建一个进程，就是创建一个车间，涉及到申请空间，而且在该空间内建至少一条流水线，但创建线程，就只是在一个车间内造一条流水线，无需申请空间，所以创建开销小）

并发编程多线程代码：

Thread()

from threading import Thread
import time
def sayhi(name):
    time.sleep(2)
    print(‘%s say hello‘ %name)
if __name__ == ‘__main__‘:
    t=Thread(target=sayhi,args=(‘egon‘,))
    t.start()
    print(‘主线程‘)

多线程和多进程的区别：https://book.apeland.cn/details/427/

线程的创建开销极小；在主进程下开启多个线程,每个线程都跟主进程的pid一样；进程之间地址空间是隔离的；同一进程内开启的多个线程是共享该进程地址空间的；

多线程用于IO密集型，如socket，爬虫，web

多进程用于计算密集型，如金融分析

现在的计算机基本上都是多核，python对于计算密集型的任务开多线程的效率并不能带来多大性能上的提升，甚至不如串行(没有大量切换)，但是，对于IO密集型的任务效率还是有显著提升的。

守护线程和守护进程的区别：https://book.apeland.cn/details/429/

多线程之GIL全局解释器锁

GIL并不是Python的特性，它是在实现Python解析器(CPython)时所引入的一个概念。

GIL本质就是一把互斥锁，既然是互斥锁，所有互斥锁的本质都一样，都是将并发运行变成串行，以此来控制同一时间内共享数据只能被一个任务所修改，进而保证数据安全。

保护不同的数据的安全，就应该加不同的锁。

GIL和Lock

1. 100个线程去抢GIL锁，即抢执行权限
2. 肯定有一个线程先抢到GIL（暂且称为线程1），然后开始执行，一旦执行就会拿到lock.acquire()</li> <li>极有可能线程1还未运行完毕，就有另外一个线程2抢到GIL，然后开始运行，但线程2发现互斥锁lock还未被线程1释放，于是阻塞，被迫交出执行权限，即释放GIL
3. 直到线程1重新抢到GIL，开始从上次暂停的位置继续执行，直到正常释放互斥锁lock，然后其他的线程再重复2 3 4的过程

Event

线程的一个关键特性是每个线程都是独立运行且状态不可预测。如果程序中的其 他线程需要通过判断某个线程的状态来确定自己下一步的操作,这时线程同步问题就会变得非常棘手。为了解决这些问题,我们需要使用threading库中的Event对象。

定时器：指定n秒后执行某操作

多线程之进程池与线程池

概述：例如进程池，就是用来存放进程的池子，本质还是基于多进程，只不过是对开启进程的数目加上了限制。

concurrent.futures 模块提供了高度封装的异步调用接口

进程池：

from concurrent.futures import ThreadPoolExecutor,ProcessPoolExecutor
import os,time,random
def task(n):
    print(‘%s is runing‘ %os.getpid())
    time.sleep(random.randint(1,3))
    return n**2
if __name__ == ‘__main__‘:
    executor=ProcessPoolExecutor(max_workers=3)
    futures=[]
    for i in range(11):
        future=executor.submit(task,i)
        futures.append(future)
    executor.shutdown(True)
    print(‘+++>‘)
    for future in futures:
        print(future.result())

线程池：把ProcessPoolExecutor换成ThreadPoolExecutor，其余用法全部相同

协程

协程：

是单线程下的并发，又称微线程，纤程。英文名Coroutine。一句话说明什么是线程：协程是一种用户态的轻量级线程，即协程是由用户程序自己控制调度的。本质就是在单线程下，由用户自己控制一个任务遇到io阻塞了就切换另外一个任务去执行，以此来提升效率。

优点：

1. 协程的切换开销更小，属于程序级别的切换，操作系统完全感知不到，因而更加轻量级
2. 2. 单线程内就可以实现并发的效果，最大限度地利用cpu

缺点：

1. 协程的本质是单线程下，无法利用多核，可以是一个程序开启多个进程，每个进程内开启多个线程，每个线程内开启协程
2. 2. 协程指的是单个线程，因而一旦协程出现阻塞，将会阻塞整个线程

特点：

1. 必须在只有一个单线程里实现并发
2. 修改共享数据不需加锁
3. 用户程序里自己保存多个控制流的上下文栈
4. 一个协程遇到IO操作自动切换到其它协程（如何实现检测IO，yield、greenlet都无法实现，就用到了gevent模块（select机制））

Gevent模块

Gevent 是一个第三方库，可以轻松通过gevent实现并发同步或异步编程

单线程里比如20个任务的代码通常会既有计算操作又有阻塞操作，我们完全可以在执行任务1时遇到阻塞，就利用阻塞的时间去执行任务2。。。。如此，才能提高效率，就要用到Gevent模块。

import gevent
def eat(name):
    print(‘%s eat 1‘ %name)
    gevent.sleep(2)
    print(‘%s eat 2‘ %name)
def play(name):
    print(‘%s play 1‘ %name)
    gevent.sleep(1)
    print(‘%s play 2‘ %name)
g1=gevent.spawn(eat,‘egon‘)
g2=gevent.spawn(play,name=‘egon‘)
g1.join()
g2.join()
#或者gevent.joinall([g1,g2])
print(‘主‘)