Python併發程式設計之執行緒中的資訊隔離（五）

Python程式設計時光發表於2018-06-21
Python程式設計執行緒

大家好，併發程式設計 進入第五篇。

上次我們說，執行緒與執行緒之間要通過訊息通訊來控制程式的執行。

講完了訊息通訊，今天就來探討下執行緒裡的資訊隔離是如何做到的。

大家注意：
資訊隔離，這並不是官方命名的名詞，也不是網上廣為流傳的名詞。是我為了方便理解而自創的，大家知道就好咯。

本文目錄

  • 初步認識資訊隔離
  • 資訊隔離的意義何在

. 初步認識資訊隔離

什麼是資訊隔離？
比如說，我們有兩個執行緒，執行緒A裡的變數，和執行緒B裡的變數值不能共享。這就是資訊隔離。

你可能要說，那變數名取不一樣不就好啦？

是的，如果所有的執行緒都不是由一個class例項化出來的同一個物件，確實是可以。這個問題我們暫且掛著，後面我再說明。

那麼，如何實現資訊隔離呢？
在Python中，其提供了threading.local這個類，可以很方便的控制變數的隔離，即使是同一個變數，在不同的執行緒中，其值也是不能共享的。

用程式碼來看下

from threading import local, Thread, currentThread

# 定義一個local例項
local_data = local()
# 在主線中，存入name這個變數
local_data.name = 'local_data'


class MyThread(Thread):
    def run(self):
        print("賦值前-子執行緒：", currentThread(),local_data.__dict__)
        # 在子執行緒中存入name這個變數
        local_data.name = self.getName()
        print("賦值後-子執行緒：",currentThread(), local_data.__dict__)


if __name__ == '__main__':
    print("開始前-主執行緒：",local_data.__dict__)

    t1 = MyThread()
    t1.start()
    t1.join()

    t2 = MyThread()
    t2.start()
    t2.join()

    print("結束後-主執行緒：",local_data.__dict__)
複製程式碼

來看看輸出結果

開始前-主執行緒： {'name': 'local_data'}

賦值前-子執行緒： <MyThread(Thread-1, started 4832)> {}
賦值後-子執行緒： <MyThread(Thread-1, started 4832)> {'name': 'Thread-1'}

賦值前-子執行緒： <MyThread(Thread-2, started 5616)> {}
賦值後-子執行緒： <MyThread(Thread-2, started 5616)> {'name': 'Thread-2'}

結束後-主執行緒： {'name': 'local_data'}
複製程式碼

從輸出來看，我們可以知道，local實際是一個字典型的物件，其內部可以以key-value的形式存入你要做資訊隔離的變數。local例項可以是全域性唯一的，只有一個。因為你在給local存入或訪問變數時，它會根據當前的執行緒的不同從不同的儲存空間存入或獲取。

基於此，我們可以得出以下三點結論：

  1. 主執行緒中的變數，不會因為其是全域性變數，而被子執行緒獲取到；
  2. 主執行緒也不能獲取到子執行緒中的變數；
  3. 子執行緒與子執行緒之間的變數也不能互相訪問。

所以如果想在當前執行緒儲存一個全域性值，並且各自執行緒（包括主執行緒）互不干擾，使用local類吧。

. 資訊隔離的意義何在

細心的你，一定已經發現了，上面那個例子，即使我們不用threading.local來做資訊隔離，兩個執行緒self.getName()本身就是隔離的，沒有任何關係的。因為這兩個執行緒是由一個class例項出的兩個不同的例項物件。自然是可以不用做隔離，因為其本身就是隔離的。

但是，現實開發中。不可排除有多個執行緒，是由一個class例項出的同一個例項物件而實現的。

譬如，現在新手特別喜歡的爬蟲專案。通常都是先給爬蟲一個主頁，然後獲取主頁下的所有連結，對這個連結再進行遍歷，一直往下，直到把所有的連結都爬完，獲取到我們所需的內容。

由於單執行緒的爬取效率實在是太低了，我們考慮使用多執行緒來工作。先使用socket和www.sina.con.cn建立一個TCP連線。然後在這個連線的基礎上，對主頁上的每個連結（我們這裡只舉news.sina.com.cn和blog.sina.com.cn這兩個子連結做例子）建立一個執行緒，這樣效率就高多了。

友情提醒：
以下程式碼，若要理解，可能需要你瞭解下socket的網路程式設計相關內容。

import threading
from functools import partial
from socket import socket, AF_INET, SOCK_STREAM

class LazyConnection:
    def __init__(self, address, family=AF_INET, type=SOCK_STREAM):
        self.address = address
        self.family = AF_INET
        self.type = SOCK_STREAM
        self.local = threading.local()

    def __enter__(self):
        if hasattr(self.local, 'sock'):
            raise RuntimeError('Already connected')
        # 把socket連線存入local中
        self.local.sock = socket(self.family, self.type)
        self.local.sock.connect(self.address)
        return self.local.sock

    def __exit__(self, exc_ty, exc_val, tb):
        self.local.sock.close()
        del self.local.sock

def spider(conn, website):
    with conn as s:
        header = 'GET / HTTP/1.1\r\nHost: {}\r\nConnection: close\r\n\r\n'.format(website)
        s.send(header.encode("utf-8"))
        resp = b''.join(iter(partial(s.recv, 100000), b''))
    print('Got {} bytes'.format(len(resp)))

if __name__ == '__main__':
    # 建立一個TCP連線
    conn = LazyConnection(('www.sina.com.cn', 80))

    # 爬取兩個頁面
    t1 = threading.Thread(target=spider, args=(conn,"news.sina.com.cn"))
    t2 = threading.Thread(target=spider, args=(conn,"blog.sina.com.cn"))
    t1.start()
    t2.start()
    t1.join()
    t2.join()
複製程式碼

輸出結果

Got 765 bytes
Got 513469 bytes
複製程式碼

如果是在這種場景下，要做到執行緒之間的狀態資訊的隔離，就肯定要藉助threading.local，所以threading.local的存在是有存在的意義的。其他還有很多場景是必須藉助threading.local才能實現的，而這些就要靠你們在真正的業務開發中去發現咯。

好了，今天就講這些內容。

                                        關注公眾號，獲取最新文章
                                                        關注公眾號，獲取最新文章


相關文章