聽說過的多進程，多線程到底是什么鬼

線程

1.何為線程

線程是操作系統能夠調度的最小單位，被包含在進程中，是進程的實際運作單位。一個進程可以並發多個線程。

2.線程的語法

創建並調用線程

import threading
import time

def sayhi(num): #定義每個線程要運行的函數

    print("running on number:%s" %num)

    time.sleep(3)

if __name__ == '__main__':

    t1 = threading.Thread(target=sayhi,args=(1,)) #生成一個線程實例
    t2 = threading.Thread(target=sayhi,args=(2,)) #生成另一個線程實例

    t1.start() #啟動線程
    t2.start() #啟動另一個線程

此外還有一種繼承式調用

import threading
import time

class MyThread(threading.Thread):
    def __init__(self,num):
        threading.Thread.__init__(self)
        self.num = num

    def run(self):#定義每個線程要運行的函數

        print("running on number:%s" %self.num)

        time.sleep(3)

if __name__ == '__main__':

    t1 = MyThread(1)
    t2 = MyThread(2)
    t1.start()
    t2.start()

另外線程還有一些內置方法

• start             線程准備就緒，等待CPU調度
• setName       為線程設置名稱
• getName       獲取線程名稱
• setDaemon   設置為后台線程或前台線程（默認）
                     如果是后台線程，主線程執行過程中，后台線程也在進行，主線程執行完畢后，后台線程不論成功與否，均停止
                     如果是前台線程，主線程執行過程中，前台線程也在進行，主線程執行完畢后，等待前台線程也執行完成后，程序停止
• join              逐個執行每個線程，執行完畢后繼續往下執行，該方法使得多線程變得無意義
• run              線程被cpu調度后自動執行線程對象的run方法

此外我們還可以自定義線程

import threading
import time
 
 
class MyThread(threading.Thread):
    def __init__(self,num):
        threading.Thread.__init__(self)
        self.num = num
 
    def run(self):#定義每個線程要運行的函數
 
        print("running on number:%s" %self.num)
 
        time.sleep(3)
 
if __name__ == '__main__':
 
    t1 = MyThread(1)
    t2 = MyThread(2)
    t1.start()
    t2.start()

線程鎖（互斥鎖）

要知道，線程之間是可以共享數據的，同時線程之間是隨機調度的。這也就意味着多個線程修改同一項數據時會出現臟數據的情況。這時，就需要我們設置線程鎖。這樣同一個時刻就只能允許一個線程執行操作。

import time
import threading

def addNum():
    global num #在每個線程中都獲取這個全局變量
    print('--get num:',num )
    time.sleep(1)
    lock.acquire() #修改數據前加鎖
    num  -=1 #對此公共變量進行-1操作
    lock.release() #修改后釋放

num = 100  #設定一個共享變量
thread_list = []
lock = threading.Lock() #生成全局鎖
for i in range(100):
    t = threading.Thread(target=addNum)
    t.start()
    thread_list.append(t)

for t in thread_list: #等待所有線程執行完畢
    t.join()

print('final num:', num )

遞歸鎖

紙面理解，就是鎖中鎖。不過，一般我們不會用到這么繁瑣的語法。這樣不僅使得代碼更加晦澀難懂，同時也會使自己的代碼出現邏輯錯誤。稍作了解就好。

import threading,time

def run1():
    print("grab the first part data")
    lock.acquire()
    global num
    num +=1
    lock.release()
    return num
def run2():
    print("grab the second part data")
    lock.acquire()
    global  num2
    num2+=1
    lock.release()
    return num2
def run3():
    lock.acquire()
    res = run1()
    print('--------between run1 and run2-----')
    res2 = run2()
    lock.release()
    print(res,res2)


if __name__ == '__main__':

    num,num2 = 0,0
    lock = threading.RLock()
    for i in range(10):
        t = threading.Thread(target=run3)
        t.start()

while threading.active_count() != 1:
    print(threading.active_count())
else:
    print('----all threads done---')
    print(num,num2)

信號量

線程鎖的存在使得一份數據同時只允許一個線程修改，當我們想指定多個線程修改同一份數據時，就可以使用信號量。

import threading,time

def run(n):
    semaphore.acquire()
    time.sleep(1)
    print("run the thread: %s\n" %n)
    semaphore.release()

if __name__ == '__main__':

    num= 0
    semaphore  = threading.BoundedSemaphore(5) #最多允許5個線程同時運行
    for i in range(20):
        t = threading.Thread(target=run,args=(i,))
        t.start()

while threading.active_count() != 1:
    pass #print threading.active_count()
else:
    print('----all threads done---')
    print(num)

事件

通過Event來實現兩個或者多個線程間的交互，事件主要提供了三個方法 set、wait、clear。

事件處理的機制：全局定義了一個“Flag”，如果“Flag”值為 False，那么當程序執行 event.wait 方法時就會阻塞，如果“Flag”值為True，那么event.wait 方法時便不再阻塞。

• clear：將“Flag”設置為False
• set：將“Flag”設置為True

import threading,time
import random
def light():
    if not event.isSet():
        event.set() #wait就不阻塞 #綠燈狀態
    count = 0
    while True:
        if count < 10:
            print('\033[42;1m--green light on---\033[0m')
        elif count <13:
            print('\033[43;1m--yellow light on---\033[0m')
        elif count <20:
            if event.isSet():
                event.clear()
            print('\033[41;1m--red light on---\033[0m')
        else:
            count = 0
            event.set() #打開綠燈
        time.sleep(1)
        count +=1
def car(n):
    while 1:
        time.sleep(random.randrange(10))
        if  event.isSet(): #綠燈
            print("car [%s] is running.." % n)
        else:
            print("car [%s] is waiting for the red light.." %n)
if __name__ == '__main__':
    event = threading.Event()
    Light = threading.Thread(target=light)
    Light.start()
    for i in range(3):
        t = threading.Thread(target=car,args=(i,))
        t.start()

條件

使得線程等待，只有滿足某條件時，才釋放n個線程

import threading
 
def run(n):
    con.acquire()
    con.wait()
    print("run the thread: %s" %n)
    con.release()
 
if __name__ == '__main__':
 
    con = threading.Condition()
    for i in range(10):
        t = threading.Thread(target=run, args=(i,))
        t.start()
 
    while True:
        inp = input('>>>')
        if inp == 'q':
            break
        con.acquire()
        con.notify(int(inp))
        con.release()

守護線程

設置守護線程，則其沒有被設置的線程為主線。當主線程退出時，無論守護線程是否完成都會退出。

import time
import threading


def run(n):

    print('[%s]------running----\n' % n)
    time.sleep(2)
    print('--done--')

def main():
    for i in range(5):
        t = threading.Thread(target=run,args=[i,])
        t.start()
        t.join(1)
        print('starting thread', t.getName())


m = threading.Thread(target=main,args=[])
m.setDaemon(True) #將main線程設置為Daemon線程,它做為程序主線程的守護線程,當主線程退出時,m線程也會退出,由m啟動的其它子線程會同時退出,不管是否執行完任務
m.start()
m.join(timeout=2)
print("---main thread done----")

Timer

定時器，指定n秒后執行某操作

from threading import Timer
 
 
def hello():
    print("hello, world")
 
t = Timer(1, hello)
t.start()  # after 1 seconds, "hello, world" will be printed

一個小小的補充 GIL（全局解釋權鎖）

在cpython的解釋器中才會存在GIL，其他的jpython這樣的編譯環境就不會存在這種情況。那么這個GIL到底是什么呢，它的存在會有什么影響呢？不急，聽我娓娓道來。

實際上，無論你啟多少個線程，你有多少個cpu, Python在執行的時候會淡定的在同一時刻只允許一個線程運行。當你使用多線程時，似乎感覺到了並發。這只是因為python上下文切換的太快了給你的錯覺。

那么GIL有什么作用呢？其實，GIL是來保證同一時間只能有一個線程來執行。

似乎和線程鎖有些相似？並不盡然，線程鎖是用戶態的鎖，而GIL則是編譯器自帶的。2.7版本以后，貌似線程鎖又被封裝到了編譯器中變得和GIL差不多，所以發現即使不使用線程鎖也不會出現臟數據（有待考證）。

 隊列queue

隊列在線程編程中特別有用，因為信息必須在多個線程之間安全地交換。現在所講的是python自帶的隊列，在后面的學習中會更加深入。目前稍作了解。

為什么我要使用隊列？

使用隊列對於我們編程而言有以下兩點好處：

• 解耦，使程序之間實現松耦合
• 提高處理效率

隊列的語法

• class queue.Queue(maxsize=0)  #先入先出
• class queue.LifoQueue(maxsize=0) #后入先出
• class queue.PriortyQueue(maxsize=0) #存儲數據時可設置優先級隊列

import queue

q = queue.Queue()

q.put(1)
q.put(2)
q.put(3)

print(q.get())
print(q.get())
print(q.get())


#結果
1
2
3

import queue

q = queue.LifoQueue()

q.put(1)
q.put(2)
q.put(3)

print(q.get())
print(q.get())
print(q.get())

#結果
3
2
1

import queue

q = queue.PriorityQueue()

q.put((2,1))
q.put((3,2))
q.put((1,3))

print(q.get())
print(q.get())
print(q.get())

#結果
(1, 3)
(2, 1)
(3, 2)

生產者消費者模型

在並發編程中使用生產者和消費者模式能夠解決絕大多數並發問題。該模式通過平衡生產線程和消費線程的工作能力來提高程序的整體處理數據的速度。

為什么要使用生產者和消費者模式

在線程世界里，生產者就是生產數據的線程，消費者就是消費數據的線程。在多線程開發當中，如果生產者處理速度很快，而消費者處理速度很慢，那么生產者就必須等待消費者處理完，才能繼續生產數據。同樣的道理，如果消費者的處理能力大於生產者，那么消費者就必須等待生產者。為了解決這個問題於是引入了生產者和消費者模式。

什么是生產者消費者模式

生產者消費者模式是通過一個容器來解決生產者和消費者的強耦合問題。生產者和消費者彼此之間不直接通訊，而通過阻塞隊列來進行通訊，所以生產者生產完數據之后不用等待消費者處理，直接扔給阻塞隊列，消費者不找生產者要數據，而是直接從阻塞隊列里取，阻塞隊列就相當於一個緩沖區，平衡了生產者和消費者的處理能力。

下面來學習一個最基本的生產者消費者模型的例子

import time,random
import queue,threading
q = queue.Queue()
def Producer(name):
  count = 0
  while count <20:
    time.sleep(random.randrange(3))
    q.put(count)
    print('Producer %s has produced %s baozi..' %(name, count))
    count +=1
def Consumer(name):
  count = 0
  while count <20:
    time.sleep(random.randrange(4))
    if not q.empty():
        data = q.get()
        print(data)
        print('\033[32;1mConsumer %s has eat %s baozi...\033[0m' %(name, data))
    else:
        print("-----no baozi anymore----")
    count +=1
p1 = threading.Thread(target=Producer, args=('A',))
c1 = threading.Thread(target=Consumer, args=('B',))
p1.start()
c1.start()

 

多進程

1.何為進程

以一個整體的形式暴露給操作系統管理，里面包含了對各種資源的調用，內存的管理，網絡管理的接口等資源，對各種資源的管理的集合，就稱為進程。

2.多進程的語法

創建並調用進程

from multiprocessing import Process
import time
def f(name):
    time.sleep(2)
    print('hello', name)

if __name__ == '__main__':
    p = Process(target=f, args=('bob',))
    p.start()
    p.join()

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("\n\n")

def f(name):
    info('\033[31;1mfunction f\033[0m')
    print('hello', name)

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

進程間的通訊

不同進程間內存是不共享的，要想實現兩個進程間的數據交換，可以用以下方法：

• Queues

from multiprocessing import Process, Queue
 
def f(q):
    q.put([42, None, 'hello'])
 
if __name__ == '__main__':
    q = Queue()
    p = Process(target=f, args=(q,))
    p.start()
    print(q.get())    # prints "[42, None, 'hello']"
    p.join()

• Pipes

from multiprocessing import Process, Pipe
 
def f(conn):
    conn.send([42, None, 'hello'])
    conn.close()
 
if __name__ == '__main__':
    parent_conn, child_conn = Pipe()
    p = Process(target=f, args=(child_conn,))
    p.start()
    print(parent_conn.recv())   # prints "[42, None, 'hello']"
    p.join()

• Managers（數據可共享）

from multiprocessing import Process, Manager
 
def f(d, l):
    d[1] = '1'
    d['2'] = 2
    d[0.25] = None
    l.append(1)
    print(l)
 
if __name__ == '__main__':
    with Manager() as 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__':
    lock = Lock()
 
    for num in range(10):
        Process(target=f, args=(lock, num)).start()

進程池

進程池內部維護一個進程序列，當使用時，則去進程池中獲取一個進程，如果進程池序列中沒有可供使用的進進程，那么程序就會等待，直到進程池中有可用進程為止。

進程池中有兩個方法：

• apply
• apply_async

from  multiprocessing import Process,Pool
import time
 
def Foo(i):
    time.sleep(2)
    return i+100
 
def Bar(arg):
    print('-->exec done:',arg)
 
pool = Pool(5)
 
for i in range(10):
    pool.apply_async(func=Foo, args=(i,),callback=Bar)
    #pool.apply(func=Foo, args=(i,))
 
print('end')
pool.close()
pool.join()#進程池中進程執行完畢后再關閉，如果注釋，那么程序直接關閉。

 

 

總結：

1.什么是進程和線程：

進程是一堆資源的集合

線程是一個指令

2.進程要操作cpu，必須要先創建一個線程，所有在同一個進程里的線程共享同一塊空間

3.進程和線程的區別：

一 線程是共享內存空間，進程的內存是獨立的

二 父進程創建兩個子進程，子進程是對父進程的克隆，兩個子進程是完全獨立的，不能互相訪問

　 兩個線程共享同一個進程，同一個進程的線程可以直接交流，兩個進程想要通信，必須通過一個中間代理實現。

三 創建新線程很簡單，創建一個新的進程需要對父進程進行一次克隆

四 一個線程可以控制和操作同一個進程的其他線程，但是進程只能操作其子進程