并发编程精要-优快云博客

1.1 进程

1.2 线程

1.3 协程

1.4 区别

六、concurrent.futures模块实现线程池和进程池

一、概念

多线程编程的目的,就是"最大限度地利用CPU资源",当某一线程的处理不需要占用CPU而只和I/O,OEMBIOS等资源打交道时,让需要占用CPU资源的其它线程有机会获得CPU资源。

每个程序执行时都会产生一个进程

但是创建进程的高消耗（每个进程都有独立的数据和代码空间），进程之间通信的不方便（消息机制），进程切换的时间太长，这些导致了多线程的提出，对于单CPU来说（没有开启超线程），在同一时间只能执行一个线程，所以如果想实现多任务，那么就只能每个进程或线程获得一个时间片，在某个时间片内，只能一个线程执行，然后按照某种策略换其他线程执行。

但是线程切换是有代价的，因此如果采用多进程，那么就需要将线程所隶属的该进程所需要的内存进行切换，这时间代价是很多的。而线程切换代价就很少，线程是可以共享内存的。所以采用多线程在切换上花费的比多进程少得多。但是，线程切换还是需要时间消耗的，所以采用一个拥有两个线程的进程执行所需要的时间比一个线程的进程执行两次所需要的时间要多一些。即采用多线程不会提高程序的执行速度，反而会降低速度，但是对于用户来说，可以减少用户的响应时间。

在多CPU下，单线程只会映射到一个CPU上，而多线程会映射到多个CPU上，超线程技术本质是多线程硬件化，所以也会加快程序的执行速度。

总结：在CPU密集型任务下，多进程更快，或者说效果更好；而IO密集型，多线程能有效提高效率。

1.1 进程

进程是具有一定独立功能的程序关于某个数据集合上的一次运行活动,
进程是系统进行资源分配和调度的一个独立单位。每个进程都有自己的独立内存空间，
不同进程通过进程间通信来通信。由于进程比较重量，占据独立的内存，
所以上下文进程间的切换开销（栈、寄存器、虚拟内存、文件句柄等）比较大，但相对比较稳定安全。

1.2 线程

线程是进程的一个实体,是 CPU 调度和分派的基本单位,
它是比进程更小的能独立运行的基本单位.
线程自己基本上不拥有系统资源,只拥有一点在运行中必不可少的资源(如程序计数器,一组寄存器和栈),
但是它可与同属一个进程的其他的线程共享进程所拥有的全部资源。
线程间通信主要通过共享内存，上下文切换很快，资源开销较少，但相比进程不够稳定容易丢失数据。

1.3 协程

协程是一种用户态的轻量级线程，协程的调度完全由用户控制。
协程拥有自己的寄存器上下文和栈。
协程调度切换时，将寄存器上下文和栈保存到其他地方，在切回来的时候，恢复先前保存的寄存器上下文和栈，
直接操作栈则基本没有内核切换的开销，可以不加锁的访问全局变量，所以上下文的切换非常快。

1.4 区别

进程与线程比较：线程是指进程内的一个执行单元,也是进程内的可调度实体。

1) 地址空间：线程是进程内的一个执行单元，进程内至少有一个线程，它们共享进程的地址空间，
而进程有自己独立的地址空间
2) 资源拥有：进程是资源分配和拥有的单位,同一个进程内的线程共享进程的资源
3) 线程是处理器调度的基本单位,但进程不是
4) 二者均可并发执行
5) 每个独立的线程有一个程序运行的入口、顺序执行序列和程序的出口，
但是线程不能够独立执行，必须依存在应用程序中，由应用程序提供多个线程执行控制

协程与线程进行比较

1) 一个线程可以多个协程，一个进程也可以单独拥有多个协程，这样 Python 中则能使用多核 CPU。
2) 线程进程都是同步机制，而协程则是异步

二、多进程，多线程概念

多线程指的是，在一个进程中开启多个线程，简单的讲：如果多个任务共用一块地址空间，那么必须在一个进程内开启多个线程。详细的讲分为4点：

　1. 多线程共享一个进程的地址空间

2. 线程比进程更轻量级，线程比进程更容易创建可撤销，在许多操作系统中，创建一个线程比创建一个进程要快10-100倍，在有大量线程需要动态和快速修改时，这一特性很有用

3. 若多个线程都是cpu密集型的，那么并不能获得性能上的增强，但是如果存在大量的计算和大量的I/O处理，拥有多个线程允许这些活动彼此重叠运行，从而会加快程序执行的速度。

4. 在多cpu系统中，为了最大限度的利用多核，可以开启多个线程，比开进程开销要小的多。（这一条并不适用于python）

 
以后写Python时：
                    IO密集型用多线程： 文件/输入输出/socket网络通信
                    计算密集型用多进程。

线程的5中状态：

线程状态转换

1.多线程

import threading

def fun1():
    print "current thread name is: %s" % threading.current_thread()

def main():
    thread = threading.Thread(target=fun1)
    thread.start()
    print "active thread count num:", threading.active_count()
    print "enum theading:", threading.enumerate()

if __name__ == '__main__':
    main()

2.多进程

#!/usr/bin/python

import multiprocessing

def fun1():
    print "current process name is: %s" % multiprocessing.current_process()

def main():
    process = multiprocessing.Process(target=fun1)
    process.start()

if __name__ == '__main__':
    main()

三、线程锁

线程中，with的作用

锁在代码块执行之前被得到并且总是在代码块执行之后被释放。

import threading
import time
 
num=0  #全局变量多个线程可以读写，传递数据
mutex=threading.Lock() #创建一个锁
 
class Mythread(threading.Thread):
    def run(self):
        global num
        with mutex:   #with Lock的作用相当于自动获取和释放锁(资源)
            for i in range(1000000): #锁定期间，其他线程不可以干活
                num+=1
        print(num)
 
mythread=[]
for i  in range(5):
    t=Mythread()
    t.start()
    mythread.append(t)
for t in mythread:
    t.join()
print("game over")
 
'''
    with mutex:   #with表示自动打开自动释放锁
        for i in range(1000000): #锁定期间，其他人不可以干活
            num+=1
#上面的和下面的是等价的
    if mutex.acquire(1):#锁住成功继续干活，没有锁住成功就一直等待，1代表独占
        for i in range(1000000): #锁定期间，其他线程不可以干活
            num+=1
        mutex.release() #释放锁
'''

3.1 python中线程的各种锁

1、GIL（全局解释器锁）的作用：多线程情况下必须存在资源的竞争，GIL是为了保证在解释器级别的线程唯一使用共享资源（cpu）

2、同步锁（Threading模块为我们提供了一个类，Threading.Lock锁）的作用：为了保证解释器级别下的自己编写的程序唯一使用共享资源产生了同步锁。

GIL VS Lock

共识：锁的目的是为了保护共享的数据，同一时间只能有一个线程来修改共享的数据

结论：保护不同的数据就应该加不同的锁。GIL 与Lock是两把锁，保护的数据不一样，前者是解释器级别的（当然保护的就是解释器级别的数据，比如垃圾回收的数据），后者是保护用户自己开发的应用程序的数据，很明显GIL不负责这件事，只能用户自定义加锁处理，即Lock

如：GIL的join是等待线程所有的代码执行完，相当于锁住了线程的所有代码，而Lock只是锁住一部分操作共享数据的代码。

线程锁：

1.threading.Lock()：用lock.acquire()加锁，lock.release()解锁

2.threading.Rlock()：通Lock()，区别：RLock 一次放行一个，支持锁多次解多次；lock 一次放行一个线程，锁一次解一次不能同时加几把锁不然一个线程都进不来(死锁) 基本不用

3.threading.BoundedSemaphore(M)：BoundedSemaphore信号量定死了放行的几个

4.threading.Condition()：根据输入放行线程个数来放行线程Condition

#!/usr/bin/env python
# -*- coding:utf-8 -*-

import time
import threading

lock = threading.Condition()  
def task(arg):
    print('线程进来了')
    lock.acquire()   
    print(111111)
    lock.wait()  # 加锁
    print(arg)
    time.sleep(1)
    lock.release()


for i in range(15):
    t = threading.Thread(target=task, args=(i,))
    t.start()

while True:
    inp = int(input(">>>"))
    lock.acquire()
    lock.notify(inp)
    lock.release()

5.threading.Event()：一次放所有理解成红绿灯就行了

#!/usr/bin/env python
# -*- coding:utf-8 -*-

import threading

lock = threading.Event()


def task(arg):
    print('线程来了')
    lock.wait()  # 加锁  红灯
    print(arg)


for i in range(5):
    t = threading.Thread(target=task, args=(i,))
    t.start()

input(">>>")
lock.set()  # 绿灯
lock.clear()  # 再次变红灯
for i in range(5):
    t = threading.Thread(target=task, args=(i,))
    t.start()
lock.set()  # 绿灯

6.线程池

一次最多放行几个线程，超过线程池的个数，会下一批在放行

#!/usr/bin/env python
# -*- coding:utf-8 -*-

from concurrent.futures import ThreadPoolExecutor
import time


def task(a1, a2):
    time.sleep(2)
    print(a1, a2)


pool = ThreadPoolExecutor(3)  # 一次最多放行3个 如果超过3个就得分次数了 12/3

for i in range(12):
    pool.submit(task, i, 2)

3.2 死锁

产生死锁的4个必要条件：

互斥条件：进程要求对所分配的资源进行排它性控制，即在一段时间内某资源仅为一进程所占用。
请求和保持条件：当进程因请求资源而阻塞时，对已获得的资源保持不放。
不剥夺条件：进程已获得的资源在未使用完之前，不能剥夺，只能在使用完时由自己释放。
环路等待条件：在发生死锁时，必然存在一个进程--资源的环形链。

解决死锁的基本方法：

资源一次性分配：一次性分配所有资源，这样就不会再有请求了：（破坏请求条件）
只要有一个资源得不到分配，也不给这个进程分配其他的资源：（破坏请保持条件）
可剥夺资源：即当某进程获得了部分资源，但得不到其它资源，则释放已占有的资源（破坏不可剥夺条件）
资源有序分配法：系统给每类资源赋予一个编号，每一个进程按编号递增的顺序请求资源，释放则相反（破坏环路等待条件）

死锁实例：

#coding=utf-8 
import time 
import threading 
class Account: 
  def __init__(self, _id, balance, lock): 
    self.id = _id 
    self.balance = balance 
    self.lock = lock 
  
  def withdraw(self, amount): 
    self.balance -= amount 
  
  def deposit(self, amount): 
    self.balance += amount 
  
  
def transfer(_from, to, amount): 
  if _from.lock.acquire():#锁住自己的账户 
    _from.withdraw(amount) 
    time.sleep(1)#让交易时间变长，2个交易线程时间上重叠，有足够时间来产生死锁 
    print 'wait for lock...'
    if to.lock.acquire():#锁住对方的账户 
      to.deposit(amount) 
      to.lock.release() 
    _from.lock.release() 
  print 'finish...'
  
a = Account('a',1000, threading.Lock()) 
b = Account('b',1000, threading.Lock()) 
threading.Thread(target = transfer, args = (a, b, 100)).start() 
threading.Thread(target = transfer, args = (b, a, 200)).start()

生产者消费者使用多线程+队列来实现模型

#!/usr/bin/env python
# -*- coding:utf-8 -*-

import time
import threading
import queue

q = queue.Queue()


def producer(arg):
    """
    生产者
    :param arg:
    :return:
    """
    while True:
        time.sleep(1)
        print("厨师生产包子%s号" % arg)
        q.put(arg)


for i in range(1, 4):
    t = threading.Thread(target=producer, args=(i,))
    t.start()


def consumer(arg):
    """
    消费者
    :param arg:
    :return:
    """
    while True:
        time.sleep(1)
        q.get(arg)
        print("消费者吃包子")


for i in range(1, 3):
    t = threading.Thread(target=consumer, args=(i,))
    t.start()

四、进程数据共享方式

进程之间数据不共享，进程数据共享办法：

1.multiprocessing.Queue()

#!/usr/bin/env python
# -*- coding:utf-8 -*-

import multiprocessing


def task(arg, q):
    q.put(arg)


if __name__ == '__main__':
    q = multiprocessing.Queue()  # 进程间数据共享
    for i in range(10):
        p = multiprocessing.Process(target=task, args=(i, q))
        p.start()

    while True:
        v = q.get()
        print(v)

2.multiprocessing.Manager()

#!/usr/bin/env python
# -*- coding:utf-8 -*-

import multiprocessing


def task(arg, dic):
    dic[arg] = 100


if __name__ == '__main__':
    m = multiprocessing.Manager()
    dic = m.dict()
    for i in range(10):
        p = multiprocessing.Process(target=task, args=(i, dic,))
        p.start()
        p.join()

    # v = dic.items()
    # print(v)
    print(dic)

进程锁和进程池都和线程差不多一样

可参考：https://www.cnblogs.com/Alexephor/p/11222944.html

五、线程间通信（数据共享）

1.共享变量：

定义全局变量
将共享变量以参数传递进去
将变量定义到其他py文件里

2.线程间使用队列（queue）进行通信（同上面👆的进程queue通信）

六、concurrent.futures模块实现线程池和进程池

以线程池举例，系统使用多线程方式运行时，会产生大量的线程创建与销毁，创建与销毁必定会带来一定的消耗，甚至导致系统资源的崩溃，这时使用线程池就是一个很好的解决方式。

“池”就说明了这里边维护了不止一个线程，线程池会提前创建好规定数量的线程，把需要使用多线程的任务提交给线程池，线程池会自己选择空闲的线程来执行提交的任务，任务完成后，线程并不会在池子中销毁，而是继续存在并等待完成下一个分配的任务。当线程池以满的时候，提交的线程会等待，也就是说线程池会有一个最大数量的运行线程限制。

concurrent.futures模块为我们提供了ThreadPoolExecutor与ProcessPoolExecutor来使用线程进程池，我们操作queue.get的时候，在等待返回结果之前会产生阻塞，cpu不能让出来做其他事情，但当我们将相应的tasks直接放入线程池/进程池时，不需要维护Queue来操心死锁的问题，线程池/进程池会自动帮我们调度。

Executor中定义了submit()方法，这个方法的作用是提交一个可执行的回调task，并返回一个future实例。future对象代表的就是给定的调用。

进程池：

from concurrent.futures import ProcessPoolExecutor
import os,time,random
def task(n):
    print('%s is running' %os.getpid())
    time.sleep(2)
    return n**2


if __name__ == '__main__':
    p=ProcessPoolExecutor()  #不填则默认为cpu的个数
    l=[]
    start=time.time()
    for i in range(10):
        obj=p.submit(task,i)   #submit()方法返回的是一个future实例，要得到结果需要用obj.result()
        l.append(obj)

    p.shutdown()  #类似用from multiprocessing import Pool实现进程池中的close及join一起的作用
    print('='*30)
    # print([obj for obj in l])
    print([obj.result() for obj in l])
    print(time.time()-start)

    #上面方法也可写成下面的方法
    # start = time.time()
    # with ProcessPoolExecutor() as p:   #类似打开文件,可省去.shutdown()
    #     future_tasks = [p.submit(task, i) for i in range(10)]
    # print('=' * 30)
    # print([obj.result() for obj in future_tasks])
    # print(time.time() - start)

线程池：

from concurrent.futures import ProcessPoolExecutor,ThreadPoolExecutor
import threading
import os,time,random
def task(n):
    print('%s:%s is running' %(threading.currentThread().getName(),os.getpid()))
    time.sleep(2)
    return n**2

if __name__ == '__main__':
    p=ThreadPoolExecutor()   #不填则默认为cpu的个数*5
    l=[]
    start=time.time()
    for i in range(10):
        obj=p.submit(task,i)
        l.append(obj)
    p.shutdown()
    print('='*30)
    print([obj.result() for obj in l])
    print(time.time()-start)

#上面方法也可写成下面的方法
    # start = time.time()
    # with ThreadPoolExecutor() as p:   #类似打开文件,可省去.shutdown()
    #     future_tasks = [p.submit(task, i) for i in range(10)]
    # print('=' * 30)
    # print([obj.result() for obj in future_tasks])
    # print(time.time() - start)

参考：

https://www.cnblogs.com/huchong/p/7459324.html

https://www.cnblogs.com/sfencs-hcy/p/10597088.html