本系列主要學(xué)習(xí)Python的基本使用和語(yǔ)法知識(shí)，后續(xù)可能會(huì)圍繞著AI學(xué)習(xí)展開(kāi)。
Python3 (1) Python語(yǔ)言的簡(jiǎn)介
Python3 (2) Python語(yǔ)法基礎(chǔ)
Python3 (3) Python函數(shù)
Python3 (4) Python高級(jí)特性
Python3 (5) Python 函數(shù)式編程
Python3 (6) Python 模塊
Python3 (7) Python 面向?qū)ο缶幊?/a>
Python3 (8) Python 面向?qū)ο蟾呒?jí)編程
Python3 (9) Python 錯(cuò)誤、調(diào)試和測(cè)試
Python3 (10) Python IO編程
Python3 (11) Python 進(jìn)程和線(xiàn)程
進(jìn)程和線(xiàn)程是多并發(fā)開(kāi)發(fā)中非常重要的兩個(gè)概念，也是衡量一個(gè)開(kāi)發(fā)人員技術(shù)水平的一個(gè)很重要依據(jù)，可想而知，應(yīng)用好進(jìn)程和線(xiàn)程的難度有多大，不是一天或者一篇文章可以學(xué)到的，而是一個(gè)開(kāi)發(fā)人員慢慢成長(zhǎng)，在項(xiàng)目中積累，根據(jù)各種應(yīng)用場(chǎng)景，選擇最佳的技術(shù)方案。所以我們今天只聊一些進(jìn)程、線(xiàn)程的概念，和Python中封裝的一些使用方法。千里之行，始于足下，我們開(kāi)始吧。

進(jìn)程和線(xiàn)程

進(jìn)程和線(xiàn)程是多任務(wù)操作系統(tǒng)中的概念 ，如Mac OS X，UNIX，Linux，Windows等操作系統(tǒng)，對(duì)于操作系統(tǒng)來(lái)說(shuō)，一個(gè)任務(wù)就是一個(gè)進(jìn)程（Process），如在一臺(tái)Android設(shè)備（android 采用Linux做內(nèi)核）上打開(kāi)一個(gè)網(wǎng)易云客戶(hù)端聽(tīng)歌、打開(kāi)一個(gè)微信客戶(hù)端聊天、打開(kāi)一個(gè)今日頭條看新聞等每一個(gè)應(yīng)用就是一個(gè)進(jìn)程，操作系統(tǒng)會(huì)輪流的將多任務(wù)調(diào)度到核心的CPU上執(zhí)行。現(xiàn)在的硬件CPU基本上都是多核，處理能力成倍的提升。 線(xiàn)程就更好理解了，因?yàn)榫€(xiàn)程是最小的執(zhí)行單元，所以每個(gè)進(jìn)程至少擁有一個(gè)線(xiàn)程，比如android的某個(gè)應(yīng)用打開(kāi)時(shí)就創(chuàng)建了一個(gè)主線(xiàn)程，如果要進(jìn)行IO操作、網(wǎng)絡(luò)請(qǐng)求等耗時(shí)操作就需要開(kāi)啟多個(gè)工作線(xiàn)程，這就是在一個(gè)進(jìn)程中同時(shí)創(chuàng)建多個(gè)子任務(wù)(Thread) 的典型例子。Python既支持多進(jìn)程，又支持多線(xiàn)程，我們會(huì)討論如何編寫(xiě)這兩種多任務(wù)程序。

多進(jìn)程

Python是跨平臺(tái)的，提供了一個(gè)跨平臺(tái)的多進(jìn)程支持。multiprocessing模塊就是跨平臺(tái)版本的多進(jìn)程模塊。但是針對(duì)Unix/Linux操作系統(tǒng)提供了一個(gè)fork()，所以這兩種操作系統(tǒng)或延伸的系統(tǒng)如mac(基于BSD（Unix的一種）內(nèi)核)等在Python的os模塊封裝的各個(gè)系統(tǒng)的方法調(diào)用包括 fork()方法，所以在Python中部分系統(tǒng)也可以通過(guò)fork()來(lái)創(chuàng)建進(jìn)程。

from multiprocessing import Pool
import os
print('Process (%s) start...' % os.getpid())
# Only works on Unix/Linux/Mac:
pid = os.fork()
if pid == 0:
    print('I am child process (%s) and my parent is %s.' % (os.getpid(), os.getppid()))
else:
    print('I (%s) just created a child process (%s).' % (os.getpid(), pid))
# works on All:
# 子進(jìn)程要執(zhí)行的代碼
def run_proc(name):
    print('Run child process %s (%s)...' % (name, os.getpid()))

if __name__=='__main__':
    print('Parent process %s.' % os.getpid())
    p = Process(target=run_proc, args=('test',))
    print('Child process will start.')
    #開(kāi)始進(jìn)程
    p.start()
    #等待子進(jìn)程結(jié)束后再繼續(xù)往下運(yùn)行
    p.join()
    print('Child process end.')

運(yùn)行結(jié)果就不寫(xiě)了，應(yīng)為我是window系統(tǒng)，第一中通過(guò)fork()復(fù)制子進(jìn)程的方法不能運(yùn)行，fork()與Process()兩種方法都可以創(chuàng)建子進(jìn)程，這樣我們就可以通過(guò)多個(gè)進(jìn)程來(lái)執(zhí)行多個(gè)任務(wù)。當(dāng)然進(jìn)程模塊還有很多方法join()可以實(shí)現(xiàn)進(jìn)程間的同步、還有守護(hù)進(jìn)程等概念。

進(jìn)程池（Pool）

Python 中提供了進(jìn)程池來(lái)批量創(chuàng)建、管理進(jìn)程

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

from multiprocessing import Pool
import os, time, random

def long_time_task(name):
    print('Run task %s (%s)...' % (name, os.getpid()))
    start = time.time()
    time.sleep(random.random() * 3)
    end = time.time()
    print('Task %s runs %0.2f seconds.' % (name, (end - start)))

if __name__=='__main__':
    print('Parent process %s.' % os.getpid())
    #核心進(jìn)程數(shù)
    p = Pool(4)
    for i in range(5):
        # 創(chuàng)建子進(jìn)程
        p.apply_async(long_time_task, args=(i,))
    print('Waiting for all subprocesses done...')
    #關(guān)閉進(jìn)程池，關(guān)閉后不能添加新的子進(jìn)程
    p.close()
    #進(jìn)程間同步，子進(jìn)程運(yùn)行完成后，代碼繼續(xù)執(zhí)行
    p.join()
    print('All subprocesses done.')

輸出結(jié)果：

Parent process 10624.
Waiting for all subprocesses done...
Run task 0 (6784)...
Run task 1 (11812)...
Run task 2 (740)...
Run task 3 (11048)...
Task 2 runs 0.07 seconds.
Run task 4 (740)...
Task 3 runs 0.30 seconds.
Task 1 runs 0.87 seconds.
Task 4 runs 0.98 seconds.
Task 0 runs 2.50 seconds.
All subprocesses done.

這就是進(jìn)程池的使用通過(guò)apply_async添加子線(xiàn)程，還提供控制線(xiàn)程池的各種方法。

子進(jìn)程

上面我們介紹了父進(jìn)程可以fork()出多個(gè)子進(jìn)程，multiprocessing模塊中通過(guò) Process()
生成子進(jìn)程，還有Pool中apply_async()批量創(chuàng)建子進(jìn)程，這幾種模式都是子進(jìn)程對(duì)自身的操作，但是很多時(shí)候子進(jìn)程需要執(zhí)行其他程序或命令，還需要控制子進(jìn)程的輸入輸出。這樣的子進(jìn)程我們可以通過(guò)subprocess來(lái)創(chuàng)建并進(jìn)程輸入輸出操作。

#!/usr/bin/env python3
# -*- coding: utf-8 -*-
import subprocess
import os
print('Run current process (%s)...' % ( os.getpid()))
print('nslookup www.python.ory')
# 轉(zhuǎn) utf-8 編碼
os.system('chcp 65001')
r = subprocess.call(['nslookup','www.python.org'])
print('Exit code',r)
print('----------------------------------------------')
print('$ nslookup')
print('Run current process (%s)...' % ( os.getpid()))
p = subprocess.Popen(['nslookup'], stdin=subprocess.PIPE, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
output, err = p.communicate(b'set q=mx\npython.org\nexit\n')
print(output.decode('utf-8'))
print('subprocess.Popen is',p.pid)
print('Exit code:', p.returncode)

輸出結(jié)果：

Run current process (8172)...
nslookup www.python.ory
Active code page: 65001
Non-authoritative answer:
Server:  public1.114dns.com
Address:  114.114.114.114

Name:    python.map.fastly.net
Addresses:  2a04:4e42:36::223
      151.101.228.223
Aliases:  www.python.org

Exit code 0
----------------------------------------------
$ nslookup
Run current process (8172)...
Default Server:  public1.114dns.com
Address:  114.114.114.114

> > Server:  public1.114dns.com
Address:  114.114.114.114

python.org  MX preference = 50, mail exchanger = mail.python.org

python.org  nameserver = ns3.p11.dynect.net
python.org  nameserver = ns2.p11.dynect.net
python.org  nameserver = ns4.p11.dynect.net
python.org  nameserver = ns1.p11.dynect.net
mail.python.org internet address = 188.166.95.178
mail.python.org AAAA IPv6 address = 2a03:b0c0:2:d0::71:1
ns1.p11.dynect.net  internet address = 208.78.70.11
ns2.p11.dynect.net  internet address = 204.13.250.11
ns3.p11.dynect.net  internet address = 208.78.71.11
ns4.p11.dynect.net  internet address = 204.13.251.11
> 
subprocess.Popen is 15896
Exit code: 0

• subprocess.call()創(chuàng)建子進(jìn)程執(zhí)行程序，然后等待子進(jìn)程完成。call()返回子進(jìn)程的 退出狀態(tài) 即 child.returncode 屬性；
• subprocess.Popen創(chuàng)建并返回一個(gè)子進(jìn)程，并在這個(gè)進(jìn)程中執(zhí)行指定的程序。并且Popen 對(duì)象提供了很多與子進(jìn)程交互的方法，如：p.communicate(input=None)和子進(jìn)程 p 交流，將參數(shù) input （字符串）中的數(shù)據(jù)發(fā)送到子進(jìn)程的 stdin，同時(shí)從子進(jìn)程的 stdout 和 stderr 讀取數(shù)據(jù)，直到EOF。返回值為二元組 (stdoutdata, stderrdata) 分別表示從標(biāo)準(zhǔn)出和標(biāo)準(zhǔn)錯(cuò)誤中讀出的數(shù)據(jù)。注意，該方法一旦調(diào)用立即阻塞父進(jìn)程，直到子進(jìn)程結(jié)束！
• 關(guān)于subprocess.Popen更多的使用方法，可以自己去了解。

進(jìn)程間通信

Python的multiprocessing模塊包裝了底層的機(jī)制，提供了Queue、Pipes等多種方式來(lái)交換數(shù)據(jù)。

做一個(gè)Queue通信的示例：

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

from multiprocessing import Process, Queue
import os, time, random

# 寫(xiě)數(shù)據(jù)進(jìn)程執(zhí)行的代碼:
def write(q):
    print('Process to write: %s' % os.getpid())
    for value in ['A', 'B', 'C']:
        print('Put %s to queue...' % value)
        q.put(value)
        time.sleep(random.random())

# 讀數(shù)據(jù)進(jìn)程執(zhí)行的代碼:
def read(q):
    print('Process to read: %s' % os.getpid())
    while True:
        value = q.get(True)
        print('Get %s from queue.' % value)

if __name__=='__main__':
    # 父進(jìn)程創(chuàng)建Queue，并傳給各個(gè)子進(jìn)程：
    q = Queue()
    pw = Process(target=write, args=(q,))
    pr = Process(target=read, args=(q,))
    # 啟動(dòng)子進(jìn)程pw，寫(xiě)入:
    pw.start()
    # 啟動(dòng)子進(jìn)程pr，讀取:
    pr.start()
    # 等待pw結(jié)束:
    pw.join()
    # pr進(jìn)程里是死循環(huán)，無(wú)法等待其結(jié)束，只能強(qiáng)行終止:
    pr.terminate()

輸出結(jié)果：

Process to read: 13760
Process to write: 9296
Put A to queue...
Get A from queue.
Put B to queue...
Get B from queue.
Put C to queue...
Get C from queue.

上面完成了一個(gè)讀/寫(xiě) 操作，將數(shù)據(jù)存儲(chǔ)在父進(jìn)程創(chuàng)建的Queue隊(duì)列中，兩個(gè)子進(jìn)程進(jìn)行寫(xiě)入/讀取操作。
進(jìn)程間的通信方法很多，這這里不深入學(xué)習(xí)。

多線(xiàn)程

線(xiàn)程是操作系統(tǒng)直接支持的執(zhí)行單元，因此，高級(jí)語(yǔ)言通常都內(nèi)置多線(xiàn)程的支持，Python也不例外，并且，Python的線(xiàn)程是真正的Posix Thread，而不是模擬出來(lái)的線(xiàn)程。Python的標(biāo)準(zhǔn)庫(kù)提供了兩個(gè)模塊：_thread和threading，_thread是低級(jí)模塊，threading是高級(jí)模塊，對(duì)_thread進(jìn)行了封裝。絕大多數(shù)情況下，我們只需要使用threading這個(gè)高級(jí)模塊。

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

import time, threading

# 新線(xiàn)程執(zhí)行的代碼:
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)

輸出結(jié)果：

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.

通過(guò)threading.Thread()就可以創(chuàng)建一個(gè)新的線(xiàn)程，執(zhí)行對(duì)應(yīng)的方法。

Lock

在多進(jìn)程中，同一個(gè)變量，各自有一份拷貝存在于每個(gè)進(jìn)程中，互不影響。而在多線(xiàn)程中，所有變量都由所有線(xiàn)程共享，所以，任何一個(gè)變量都可以被任何一個(gè)線(xiàn)程修改，這就可能導(dǎo)致執(zhí)行的結(jié)果與預(yù)期不符，所以在處理多線(xiàn)程的問(wèn)題中，出現(xiàn)了一個(gè)線(xiàn)程鎖。

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

import time, threading

# 假定這是你的銀行存款:
balance = 0

def change_it(n):
    # 先存后取，結(jié)果應(yīng)該為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)

以上是兩個(gè)線(xiàn)程，同時(shí)操作同一個(gè)函數(shù)，邏輯上輸出的結(jié)果應(yīng)該是0，但是多次運(yùn)行會(huì)有不同的結(jié)果。因?yàn)楦呒?jí)語(yǔ)言的一條語(yǔ)句在CPU執(zhí)行時(shí)是若干條語(yǔ)句，所以多個(gè)線(xiàn)程同時(shí)使用某個(gè)變量時(shí)，會(huì)發(fā)生錯(cuò)位的現(xiàn)象。Python中通過(guò)threading.Lock()來(lái)實(shí)現(xiàn)。

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

import time, threading

# 假定這是你的銀行存款:
balance = 0
lock = threading.Lock()

def change_it(n):
    # 先存后取，結(jié)果應(yīng)該為0:
    global balance
    balance = balance + n
    balance = balance - n

def run_thread(n):
    for i in range(100000):
        # 先要獲取鎖:
        lock.acquire()
        try:
            # 放心地改吧:
            change_it(n)
        finally:
            # 改完了一定要釋放鎖:
            lock.release()

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)

輸出結(jié)果：

0

這次無(wú)論執(zhí)行多少次，結(jié)果都是0。多個(gè)線(xiàn)程同時(shí)執(zhí)行l(wèi)ock.acquire()時(shí)，只有一個(gè)線(xiàn)程能成功地獲取鎖，然后繼續(xù)執(zhí)行代碼，其他線(xiàn)程就繼續(xù)等待直到獲得鎖為止。在執(zhí)行完成一次后一定要釋放鎖lock.release(),我們用```try...finally...`確保鎖被釋放，不然會(huì)造成死鎖

• 好處：確保了某段關(guān)鍵代碼只能由一個(gè)線(xiàn)程從頭到尾完整地執(zhí)行。
• 壞處：1. 先是阻止了多線(xiàn)程并發(fā)執(zhí)行，包含鎖的某段代碼實(shí)際上只能以單線(xiàn)程模式執(zhí)行，效率就大大地下降了。 2. 由于可以存在多個(gè)鎖，不同的線(xiàn)程持有不同的鎖，并試圖獲取對(duì)方持有的鎖時(shí)，可能會(huì)造成死鎖，導(dǎo)致多個(gè)線(xiàn)程全部掛起，既不能執(zhí)行，也無(wú)法結(jié)束，只能靠操作系統(tǒng)強(qiáng)制終止。

多核CPU

Python解釋器由于設(shè)計(jì)時(shí)有GIL全局鎖，導(dǎo)致了多線(xiàn)程無(wú)法利用多核。Python的線(xiàn)程雖然是真正的線(xiàn)程，但解釋器執(zhí)行代碼時(shí)，有一個(gè)GIL鎖：Global Interpreter Lock，任何Python線(xiàn)程執(zhí)行前，必須先獲得GIL鎖，然后，每執(zhí)行100條字節(jié)碼，解釋器就自動(dòng)釋放GIL鎖，讓別的線(xiàn)程有機(jī)會(huì)執(zhí)行。這個(gè)GIL全局鎖實(shí)際上把所有線(xiàn)程的執(zhí)行代碼都給上了鎖，所以，多線(xiàn)程在Python中只能交替執(zhí)行，即使100個(gè)線(xiàn)程跑在100核CPU上，也只能用到1個(gè)核。Python雖然不能利用多線(xiàn)程實(shí)現(xiàn)多核任務(wù)，但可以通過(guò)多進(jìn)程實(shí)現(xiàn)多核任務(wù)。多個(gè)Python進(jìn)程有各自獨(dú)立的GIL鎖，互不影響。

ThreadLocal

ThreadLoacal 可以是一個(gè)全局變量，但是每個(gè)線(xiàn)程都只能讀寫(xiě)自己線(xiàn)程的獨(dú)立副本，ThreadLocal解決了參數(shù)在一個(gè)線(xiàn)程中各個(gè)函數(shù)之間互相傳遞的問(wèn)題，而不用考慮管理鎖的問(wèn)題。

#!/usr/bin/env python3
# -*- coding: utf-8 -*-
import threading

# 創(chuàng)建全局ThreadLocal對(duì)象:
local_school = threading.local()

def process_student():
    # 獲取當(dāng)前線(xiàn)程關(guān)聯(lián)的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=('張三',), name='Thread-1')
t2 = threading.Thread(target= process_thread, args=('李四',), name='Thread-2')
t1.start()
t2.start()
t1.join()
t2.join()

輸出結(jié)果：

Hello, 張三 (in Thread-1)
Hello, 李四 (in Thread-2)

上面實(shí)現(xiàn)了student變成一個(gè) local_school對(duì)象的屬性，每個(gè)Thread都可以讀取student屬性，每個(gè)線(xiàn)程讀取的都是該線(xiàn)程的局部變量，不會(huì)造成錯(cuò)亂，也無(wú)需管理鎖的問(wèn)題。ThreadLocal最常用的地方就是為每個(gè)線(xiàn)程綁定一個(gè)數(shù)據(jù)庫(kù)連接，HTTP請(qǐng)求，用戶(hù)身份信息等配置信息，這樣一個(gè)線(xiàn)程的所有調(diào)用到的處理函數(shù)都可以非常方便地訪(fǎng)問(wèn)這些資源。

進(jìn)程 VS 線(xiàn)程

首先要實(shí)現(xiàn)多任務(wù)的執(zhí)行，應(yīng)該采用Master-Worker模式，Master負(fù)責(zé)分配任務(wù)，Worker負(fù)責(zé)執(zhí)行任務(wù)：

• 多進(jìn)程實(shí)現(xiàn)Master-Worker，主進(jìn)程就是Master，其他進(jìn)程就是Worker。
  1. 多進(jìn)程模式最大的優(yōu)點(diǎn)就是穩(wěn)定性高，因?yàn)橐粋€(gè)子進(jìn)程崩潰了，不會(huì)影響主進(jìn)程和其他子進(jìn)程。（當(dāng)然主進(jìn)程掛了所有進(jìn)程就全掛了，但是Master進(jìn)程只負(fù)責(zé)分配任務(wù)，掛掉的概率低）著名的Apache最早就是采用多進(jìn)程模式。
  2. 多進(jìn)程模式的缺點(diǎn)是創(chuàng)建進(jìn)程的代價(jià)大，在Unix/Linux系統(tǒng)下，用fork調(diào)用還行，在Windows下創(chuàng)建進(jìn)程開(kāi)銷(xiāo)巨大。另外，操作系統(tǒng)能同時(shí)運(yùn)行的進(jìn)程數(shù)也是有限的，在內(nèi)存和CPU的限制下，如果有幾千個(gè)進(jìn)程同時(shí)運(yùn)行，操作系統(tǒng)連調(diào)度都會(huì)成問(wèn)題。
• 多線(xiàn)程實(shí)現(xiàn)Master-Worker，主線(xiàn)程就是Master，其他線(xiàn)程就是Worker。
  1. 多線(xiàn)程模式通常比多進(jìn)程快一點(diǎn)，但是也快不到哪去，而且，多線(xiàn)程模式致命的缺點(diǎn)就是任何一個(gè)線(xiàn)程掛掉都可能直接造成整個(gè)進(jìn)程崩潰，因?yàn)樗芯€(xiàn)程共享進(jìn)程的內(nèi)存。

所以為了緩解這個(gè)問(wèn)題，IIS和Apache現(xiàn)在又有多進(jìn)程+多線(xiàn)程的混合模式，但這種模式的復(fù)雜度更大。

進(jìn)程/線(xiàn)程切換

無(wú)論是多進(jìn)程還是多線(xiàn)程，只要數(shù)量一多，效率肯定上不去 ，因?yàn)樵谶M(jìn)程/線(xiàn)程切換過(guò)程中，要進(jìn)行保護(hù)現(xiàn)場(chǎng)、準(zhǔn)備新的環(huán)境會(huì)耗費(fèi)很多資源、時(shí)間。在任務(wù)達(dá)到一定的限度，就會(huì)消耗掉系統(tǒng)所有的資源，結(jié)果效率急劇下降，所有任務(wù)都做不好。

計(jì)算密集型 vs IO密集型

在考慮多任務(wù)時(shí)，要考慮任務(wù)的類(lèi)型：

• 計(jì)算密集型任務(wù)的特點(diǎn)是要進(jìn)行大量的計(jì)算，消耗CPU資源，比如計(jì)算圓周率、對(duì)視頻進(jìn)行高清解碼等等，全靠CPU的運(yùn)算能力。這樣的任務(wù)應(yīng)該開(kāi)啟與CPU核心數(shù)相同的任務(wù)數(shù)量，來(lái)保證最大效率的執(zhí)行計(jì)算，另外Python這樣的腳本語(yǔ)言運(yùn)行效率很低，完全不適合計(jì)算密集型任務(wù)。應(yīng)該使用 C 語(yǔ)言等接近匯編語(yǔ)言來(lái)編寫(xiě)。
• IO密集型 ，主要涉及到網(wǎng)絡(luò)、磁盤(pán)IO的任務(wù)都是IO密集型任務(wù)，這類(lèi)任務(wù)的特點(diǎn)是CPU消耗很少，任務(wù)的大部分時(shí)間都在等待IO操作完成（因?yàn)镮O的速度遠(yuǎn)遠(yuǎn)低于CPU和內(nèi)存的速度），對(duì)于IO密集型任務(wù)，最合適的語(yǔ)言就是開(kāi)發(fā)效率最高（代碼量最少）的語(yǔ)言。

異步IO

現(xiàn)代操作系統(tǒng)支持異步IO，單進(jìn)程單線(xiàn)程模型來(lái)執(zhí)行多任務(wù)，這種模型稱(chēng)為事件驅(qū)動(dòng)模型。Nginx就是支持異步IO的Web服務(wù)器。對(duì)于Python語(yǔ)言，單線(xiàn)程的異步編程模型稱(chēng)為協(xié)程，有了協(xié)程的支持，就可以基于事件驅(qū)動(dòng)編寫(xiě)高效的多任務(wù)程序。

分布式進(jìn)程

分布式進(jìn)程只做了解，因?yàn)檫M(jìn)程是支持分布到多臺(tái)機(jī)器上，而線(xiàn)程是不能的。在Python的multiprocessing模塊不但支持多進(jìn)程，其中managers子模塊還支持把多進(jìn)程分布到多臺(tái)機(jī)器上。一個(gè)服務(wù)進(jìn)程可以作為調(diào)度者，將任務(wù)分布到其他多個(gè)進(jìn)程中，依靠網(wǎng)絡(luò)通信。Python的分布式進(jìn)程接口簡(jiǎn)單，封裝良好，適合需要把繁重任務(wù)分布到多臺(tái)機(jī)器的環(huán)境下。

參考

https://www.liaoxuefeng.com/wiki/0014316089557264a6b348958f449949df42a6d3a2e542c000/0014319272686365ec7ceaeca33428c914edf8f70cca383000
http://www.cnblogs.com/Security-Darren/p/4733368.html