【Python入门】22.进程编程之 多进程与多线程的比较

摘要：多线程的介绍；Lock；Threadlocal；多进程与多线程的优缺点；计算密集型与IO密集型；异步IO

---

*写在前面：为了更好的学习python，博主记录下自己的学习路程。本学习笔记基于廖雪峰的Python教程，如有侵权，请告知删除。欢迎与博主一起学习Pythonヽ(￣▽￣)ﾉ *

---

目录

进程和线程
多线程
• Lock
• Threadlocal
多进程与多线程的优缺点
计算密集型和IO密集型
异步IO

进程和线程

多线程

除了通过多进程实现“多任务”外，还能通过多线程来实现。

线程是操作系统最小的执行单元，一个进程至少包含一个线程。

Python中提供了threading模块来实现多线程。threadding高级模块还封装了_thread模块，一般我们只使用threading高级模块。

启动一个线程，就是创建一个threading实例，通过start( )方法运行即可。

threading实例的创建:

Thread(group=None, target=None, name=None, args=(), kwargs={}) 

参数说明：

group：线程所属组（基本不用）
target：线程调用对象
name：线程别名
args：调用对象的位置参数
kwargs：调用对象的关键字参数

看一个简单的例子（代码转自廖雪峰的官方网站）：

import time, threading

# 新线程执行的代码:
def loop():
    print('thread %s is running...' % threading.current_thread().name)
    n = 0
    while n < 5:
        n = n + 1
        print('thread %s >>> %s' % (threading.current_thread().name, n))
        time.sleep(1)
    print('thread %s ended.' % threading.current_thread().name)

print('thread %s is running...' % threading.current_thread().name)
t = threading.Thread(target=loop, name='LoopThread')
t.start()
t.join()
print('thread %s ended.' % threading.current_thread().name)

执行结果：

thread MainThread is running...
thread LoopThread is running...
thread LoopThread >>> 1
thread LoopThread >>> 2
thread LoopThread >>> 3
thread LoopThread >>> 4
thread LoopThread >>> 5
thread LoopThread ended.
thread MainThread ended.

其中current_thread()方法是返回当前线程的实例，current_thread().name即返回实例的名称。主线程实例的名称为MainThread，子线程名称在创建时定义，在上例中即为LoopThread。如果子线程不起名字Python就自动给线程命名为Thread-1，Thread-2……

• Lock

多线程与多进程不同的一点是，对于同一变量，多进程会各自拷贝一份在每个进程中，互不影响，而多线程所有线程共享的。也就是说多线程会同时更改一个变量，而最终变量可能达不到我们想要的结果。

要解决这个问题，就要给线程的调用对象加一把锁，使得该调用对象只能被一个线程调用，当锁解开时，才能被下一个线程调用。

创建一个锁通过threading.Lock( )实现，然后通过lock.acquire( )进行加锁，通过lock.release( )进行解锁。看个简单的例子：

import time,threading

def fn(n):
    for x in range(n):
        print(threading.current_thread().name +':'+ str(x))
        time.sleep(0.01)

a = threading.Thread(target = fn, name='a', args=(5,))
b = threading.Thread(target = fn, name='b', args=(5,))
a.start()
b.start()

运行结果：

a:0 
b:0 
b:1 
a:1 
b:2 
a:2 
a:3 
b:3 
a:4 
b:4 

可以发现，线程a与线程b是交替执行的，且没有先后顺序。如果我们想要先执行完线程a，再执行线程b的话，就可以加lock。

import time,threading

lock = threading.Lock()

def fn(n):
    lock.acquire()
    for x in range(n):
        print(threading.current_thread().name +':'+ str(x))
        time.sleep(0.01)
    lock.release()
    
a = threading.Thread(target = fn, name='a', args=(5,))
b = threading.Thread(target = fn, name='b', args=(5,))
a.start()
b.start()

运行结果：

a:0 
a:1 
a:2 
a:3 
a:4 
b:0 
b:1 
b:2 
b:3 
b:4 

多线程同时操作一个变量，可能会把数据内容改乱，廖雪峰官网就给出了这样一个例子：

import time, threading

# 假定这是你的银行存款:
balance = 0

def change_it(n):
    # 先存后取，结果应该为0:
    global balance
    balance = balance + n
    balance = balance - n

def run_thread(n):
    for i in range(100000):
        change_it(n)

t1 = threading.Thread(target=run_thread, args=(5,))
t2 = threading.Thread(target=run_thread, args=(8,))
t1.start()
t2.start()
t1.join()
t2.join()
print(balance)

理论上，最终打印出的balance值是0，因为一存一取同样的数据，原本值应该是不变的。但是运行结果却有可能为5或8或-5或-8。

这就是的多线程交替运行原因，如果t1与t2以这种顺序运行，就会出现-8的结果：

初始值 balance = 0

t1: x1 = balance + 5  # x1 = 0 + 5 = 5

t2: x2 = balance + 8  # x2 = 0 + 8 = 8
t2: balance = x2      # balance = 8

t1: balance = x1      # balance = 5
t1: x1 = balance - 5  # x1 = 5 - 5 = 0
t1: balance = x1      # balance = 0

t2: x2 = balance - 8  # x2 = 0 - 8 = -8
t2: balance = x2   # balance = -8

结果 balance = -8

这个时候只要在函数change_it( )内加上一把锁就能保证balance值为0了。

• Threadlocal

在多线程的环境下，每个线程一般都使用局部变量，这样不受其他线程影响，使用全局变量的话还要加锁。

使用局部变量的话，会存在另一个问题——变量的传递很麻烦。

我们可以用Threadlocal来解决这个问题（以下代码转自廖雪峰官网）：

import threading

# 创建全局ThreadLocal对象:
local_school = threading.local()

def process_student():
    # 获取当前线程关联的student:
    std = local_school.student
    print('Hello, %s (in %s)' % (std, threading.current_thread().name))

def process_thread(name):
    # 绑定ThreadLocal的student:
    local_school.student = name
    process_student()

t1 = threading.Thread(target= process_thread, args=('Alice',), name='Thread-A')
t2 = threading.Thread(target= process_thread, args=('Bob',), name='Thread-B')
t1.start()
t2.start()
t1.join()
t2.join()

代码解析：

通过threading.local( )方法我们创建了一个local_school对象，创建t1、t2线程，并调用process_thread函数对象，在该函数内部每个线程创建了对应的local_school.student属性。之后调用函数process_student( )，通过process_student( )把属性打印出来。

我们可以把local_school看成全局变量。每个线程都可以读写其student属性，而每个属性local_school.student都是对应线程里的局部变量，互不影响，也不用加lock。

ThreadLocal最常用的地方就是为每个线程绑定一个数据库连接，HTTP请求，用户身份信息等，这样一个线程的所有调用到的处理函数都可以非常方便地访问这些资源。

多进程与多线程的优缺点

要实现“多任务”，一般会设置Master-Worker的模式，Master负责分配任务，而Worker负责执行任务。主进程/主线程就是Master，其他进程/线程就是Worker。

下面看一下多进程与多线程的优缺点：

·	多进程	多线程
优点	稳定性高，一个子进程Worker的崩溃不会影响其他进程	效率会比多进程高
缺点	创建代价高，同时运行的进程数量有限	稳定性低，一个子线程Worker的崩溃会导致主线程Master的崩溃

无论是使用多进程还是多线程，当数量增多时，效率肯定会降低。因为操作系统会忙于切换进程\线程，而不是执行任务。

当数量到达一定限度，会消耗掉系统所有的资源，结果所有任务都完成不了。

计算密集型和IO密集型

是否采用多任务模式还要考虑任务的类型。任务的类型可以分为：计算密集型和IO密集型。

计算密集型：是指需要进行大量计算，消耗CPU资源的任务，如计算圆周率等。对于计算密集型任务，同时进行的数量越多，CPU执行效率越低，想要充分利用CPU，其同时进行的数量应该与CPU核心数相等。

IO密集型：是指CPU消耗少，而需要进行大量IO操作的任务，如涉及到网络、磁盘IO等任务。对于IO密集型任务，同时进行的数量越多，CPU执行效率越高，因为CPU的执行速度远远高于IO操作速度，任务的大部分时间都在等待IO操作完成。

异步IO

由于CPU和IO之间巨大的速度差异，我们才需要多进程或者多线程模型来支持多任务并发执行。

但如今的操作系统已经支持异步IO了，如果充分利用异步IO，就可以实现单进程单线程来实现多任务。这种模型称为事件驱动模型。

在python中，单线程的异步编程模型称为协程，有了协程的支持，就可以基于事件驱动编写高效的多任务程序。后面的内容会介绍到协程。

---

以上就是本节的全部内容，感谢你的阅读。

下一节内容：正则表达式

有任何问题与想法，欢迎评论与吐槽。

和博主一起学习Python吧(￣▽￣)~*