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的網絡編程相關內容。我在前幾天的文章中有發佈一篇相關的文章，沒有基礎的同窗能夠先去看看那篇文章。

點擊跳轉：「原創 Python進階開發之網絡編程」

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才能實現的，而這些就要靠大家在真正的業務開發中去發現咯。