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才能实现的，而这些就要靠大家在真正的业务开发中去发现咯。