Python高级知识点学习（六）

围棋少年

Python中的迭代协议

迭代协议有两个概念：

1. 可迭代类型（Iterable）
2. 迭代器（Iterator）

迭代器：迭代器是访问集合内元素的一种方式， 一般用来遍历数据。

迭代器和以下标的访问方式不一样， 迭代器是不能返回的, 迭代器提供了一种惰性方式数据的方式。

可迭代对象（Iterable） 和 迭代器（Iterator） 是不同的。

可迭代对象：

• 实现__iter__这个魔法函数

迭代器：

• 实现__next__这个魔法函数
• 实现__iter__这个魔法函数

from collections.abc import Iterable, Iterator
a = [1, 2]

print(isinstance(a, Iterable))
print(isinstance(a, Iterator))

打印结果：
True
False

上边代码，因为a是一个list，而list是一个可迭代对象并不是迭代器，因为list对象中没有__next__方法。

生成器

生成器函数：函数里只要有yield关键字，它就是生成器对象。
生成器对象在python编译字节码的时候就产生了。
生成器对象也是实现了迭代器协议的，所以可以使用for循环遍历到它的值。

def gen_func():
    yield 1

gen = gen_func()
for value in gen:
    print(value)

打印结果：
1

Python 中的GIL

GIL：global interpreter lock （cpython）
GIL：全局解释器锁。

python中一个线程对应于c语言中的一个线程。

GIL使得同一个时刻只有一个线程在一个cpu上执行字节码, 也就意味着无法将多个线程映射到多个cpu上执行。

GIL锁分配给某一线程后，并不是说这个线程执行完了之后它才会释放把它交给另外一个线程，它不是整个过程完全占有，它实际上是会在适当的时刻释放的，是结合了字节码执行的行数比如他执行了1000行字节码之后，它会释放，然后另外一个线程就可以得到运行。

GIL释放：

1. 会根据执行的字节码行数以及时间片释放gil。
2. gil在遇到io的操作时候主动释放。

total = 0

def add():
    global total
    for i in range(1000000):
        total += 1


def desc():
    global total
    for i in range(1000000):
        total -= 1


thread1 = threading.Thread(target=add)
thread2 = threading.Thread(target=desc)
thread1.start()
thread2.start()

thread1.join()
thread2.join()
print(total)

上边代码两个线程分别执行两个函数，两个函数对同一变量做加减操作，本来应该先加到1000000再减1000000最终打印出0，但事实上是不会打印0的。

多线程编程

IO密集型时，适合多线程。
CPU密集型时，适合多进程。

多线程编程是我们几乎所有编程语言中都会遇到的问题。

操作系统能够切换和调度的最小单元是线程。

在最开始的时候，操作系统能够调度的最小单元是进程，但是由于进程对系统资源消耗非常大，所以后期就演变出了线程。

第一种方式：通过Thread类实例化

def get_detail_html(url):
    print("get detail html started")
    time.sleep(2)
    print("get detail html end")


def get_detail_url(url):
    print("get detail url started")
    time.sleep(4)
    print("get detail url end")


if __name__ == "__main__":
    thread1 = threading.Thread(target=get_detail_html, args=("",))
    thread2 = threading.Thread(target=get_detail_url, args=("",))
    # 设置为守护线程，随着主线程退出，子线程也退出
    #thread1.setDaemon(True)
    #thread2.setDaemon(True)
    start_time = time.time()

    thread1.start()
    thread2.start()
    # 等待线程1，2执行完成 再执行完主线程；
    thread1.join()
    thread2.join()

    print(time.time() - start_time)

上边代码中，两个线程分别执行两个函数，主线程下有两个子线程。

thread1.setDaemon(True)这个操作是把thread1设置为守护线程，随着主线程退出，thread1也退出。
thread1.join()这个操作是把主线程等待thread1执行完再执行完主线程。

第二种方式：通过重载Thread来实现多线程

def get_detail_html(url):
    print("get detail html started")
    time.sleep(2)
    print("get detail html end")


def get_detail_url(url):
    print("get detail url started")
    time.sleep(4)
    print("get detail url end")



class GetDetailHtml(threading.Thread):
    def __init__(self, name):
        super().__init__(name=name)

    def run(self):
        print("get detail html started")
        time.sleep(2)
        print("get detail html end")


class GetDetailUrl(threading.Thread):
    def __init__(self, name):
        super().__init__(name=name)

    def run(self):
        print("get detail url started")
        time.sleep(4)
        print("get detail url end")


if  __name__ == "__main__":
    thread1 = GetDetailHtml("get_detail_html")
    thread2 = GetDetailUrl("get_detail_url")
    start_time = time.time()
    thread1.start()
    thread2.start()

    thread1.join()
    thread2.join()

    print("last time: {}".format(time.time()-start_time))

上边代码继承threading.Thread必须重载run方法。

线程同步Lock、RLock

为什么要线程同步？
现有两个函数，分别是对全局变脸a进行加减操作，两个函数使用两个线程来运行，一个线程负责把a加一，另一个负责把a减一，上代码：

a = 0
def add(a):
    a += 1

def desc(a):
    a-=1

首先使用内置方法dis()看一下两个函数字节码是什么样子的：

import dis

def add(a):
    a += 1

def desc(a):
    a-=1

print(dis.dis(add))
print(dis.dis(desc))

打印结果：
 63           0 LOAD_FAST                0 (a)
              2 LOAD_CONST               1 (1)
              4 INPLACE_ADD
              6 STORE_FAST               0 (a)
              8 LOAD_CONST               0 (None)
             10 RETURN_VALUE
None
 66           0 LOAD_FAST                0 (a)
              2 LOAD_CONST               1 (1)
              4 INPLACE_SUBTRACT
              6 STORE_FAST               0 (a)
              8 LOAD_CONST               0 (None)
             10 RETURN_VALUE
None

上边代码打印结果：

看下add的里边字节码：

1. LOAD_FAST：首先把 a LOAD 到内存中
2. LOAD_CONST ：再把1 LOAD 到内存中
3. INPLACE_ADD：执行加的操作
4. STORE_FAST：将加完的值赋值给 a

desc里边也是一样的，分四步，不同的是desc里执行的是减法。

如果同时执行add字节码和desc字节码时，之前笔记中提过，执行以上四个步骤时随时都可能释放gil锁，因为字节码的数量已经满了，以上四步任何一步骤都可能释放gil锁切换到另外一个线程，所以有可能造成一个结果，就是a要么等于1，要么等于-1，但是我们期望的是a 等于0，这时候就需要线程同步来解决问题。

我们希望在执行add函数的代码段时，另一个线程中的desc代码段是停止的，这就是线程同步机制。

python给我们提供了一个机制，叫做锁：
from threading import Lock
在运行一个代码段时，加一把锁，等运行完了，再释放锁。

from threading import Lock
total = 0
# 声明一把锁
lock = RLock()

def add():
    global lock
    global total
    for i in range(1000000):
        # 获得锁
        lock.acquire()
        total += 1
        # 释放锁
        lock.release()

def desc():
    global total
    global lock
    for i in range(1000000):
        lock.acquire()
        total -= 1
        lock.release()

import threading
thread1 = threading.Thread(target=add)
thread2 = threading.Thread(target=desc)
thread1.start()
thread2.start()

thread1.join()
thread2.join()
print(total)

打印结果：
0

上边代码不管累加多少次最终结果都是0。
如果没有释放锁，会导致死锁。

使用锁会影响性能。

RLock：
在同一个线程里面，可以连续调用多次acquire， 一定要注意acquire的次数要和release的次数相等。

在同一个线程中，可以使用RLock。