Chinaunix首页 | 论坛 | 博客
  • 博客访问: 147279
  • 博文数量: 51
  • 博客积分: 0
  • 博客等级: 民兵
  • 技术积分: 255
  • 用 户 组: 普通用户
  • 注册时间: 2020-12-30 16:49
文章分类
文章存档

2021年(48)

2020年(3)

我的朋友

分类: Python/Ruby

2021-01-08 13:56:00

大家好,`并发编程` 进入第五篇。


上次我们说,线程与线程之间要通过消息通信来控制程序的执行。


讲完了消息通信,今天就来探讨下线程里的`信息隔离`是如何做到的。


> **大家注意**:
> `信息隔离`,这并不是官方命名的名词,也不是网上广为流传的名词。是我为了方便理解而自创的,大家知道就好咯。


>本期小编推送2021初学者一定会用到的Python资料,含有小编自己呕心沥血整理的免费书籍/视频/在线文档和编辑器/源代码,关于`Python`的安装qun:850973621






## 本文目录


*   初步认识信息隔离
*   信息隔离的意义何在


### . 初步认识信息隔离


什么是`信息隔离`?
比如说,咱有两个线程,线程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'}


赋值前-子线程: {}
赋值后-子线程: {'name': 'Thread-1'}


赋值前-子线程: {}
赋值后-子线程: {'name': 'Thread-2'}


结束后-主线程: {'name': 'local_data'}
复制代码
```


从输出来看,我们可以知道,`local`实际是一个`字典型`的对象,其内部可以以`key-value`的形式存入你要做信息隔离的变量。local实例可以是`全局唯一`的,只有一个。因为你在给local存入或访问变量时,它会根据当前的线程的不同从不同的`存储空间`存入或获取。


基于此,我们可以得出以下三点结论:


> 1.  主线程中的变量,不会因为其是全局变量,而被子线程获取到;
> 2.  主线程也不能获取到子线程中的变量;
> 3.  子线程与子线程之间的变量也不能互相访问。


所以如果想在当前线程保存一个全局值,并且各自线程(包括主线程)互不干扰,使用local类吧。


### . 信息隔离的意义何在


细心的你,一定已经发现了,上面那个例子,即使我们不用`threading.local`来做信息隔离,两个线程`self.getName()`本身就是隔离的,没有任何关系的。因为这两个线程是由一个class实例出的两个不同的实例对象。自然是可以不用做隔离,因为其本身就是隔离的。


但是,现实开发中。不可排除有多个线程,是由一个class实例出的同一个实例对象而实现的。


譬如,现在新手特别喜欢的爬虫项目。通常都是先给爬虫一个主页,然后获取主页下的所有链接,对这个链接再进行遍历,一直往下,直到把所有的链接都爬完,获取到我们所需的内容。


由于单线程的爬取效率实在是太低了,我们考虑使用多线程来工作。先使用`socket`和``建立一个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(('', 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`才能实现的,而这些就要靠你们在真正的业务开发中去发现咯。


好了,今天就讲这些内容。






原文链接:


阅读(1112) | 评论(0) | 转发(0) |
给主人留下些什么吧!~~