线程和进程的归纳（一）

 

参考学习资料：

1.知乎文章 深入理解python中的GIL https://zhuanlan.zhihu.com/p/75780308

2.《cook book》及python官方文档

3.CSDN博主「杨花似雪~」原文链接：https://blog.csdn.net/weixin_41594007/article/details/79485847

4.bobby 老师慕课网课程

1.全局锁（GIL）

1. GIL是什么？
 python 根据解释器可以分为：

1. CPython     （C语言开发的）
2. IPython      （IPython是基于CPython之上的一个交互式解释器）
3. PyPy          （PyPy采用JIT技术）
4. Jython        （运行在Java平台）

IronPython  （运行在微软.Net平台）

GIL并不是Python的特性，它只和cpython有关。

每个线程在执行时候都需要先获取GIL，保证同一时刻只有一个线程可以执行代码，即同一时刻只有一个线程使用CPU，也就是说多线程并不是真正意义上的同时执行。

2.GIL的历史形成原因和困局

Guido van Rossum（吉多·范罗苏姆）创建python时就只考虑到单核cpu，解决多线程之间数据完整性和状态同步的最简单方法自然就是加锁， 于是有了GIL这把超级大锁。因为cpython解析只允许拥有GIL全局解析器锁才能运行程序，这样就保证了保证同一个时刻只允许一个线程可以使用cpu。由于大量的程序开发者接收了这套机制,现在代码量越来越多,已经不容易通过c代码去解决这个问题。

由于多线程在Python中只能交替执行，即使有8个线程跑在8核CPU上，也只能用到1个核。所以GIL 最大的问题就是 Python 的多线程程序并不能利用多核 CPU 的优势。

3. 如何避免GIL的影响

1. 在以IO操作为主的IO密集型应用中，多线程和多进程的性能区别并不大，原因在于即使在Python中有GIL锁的存在，由于线程中的IO操作会使得线程立即释放GIL，切换到其他非IO线程继续操作，提高程序执行效率。相比进程操作，线程操作更加轻量级，线程之间的通讯复杂度更低，建议使用多线程。

2. 如果是计算密集型的应用，可以使用多进程来处理。建立一个Processing pool ，当一个线程想要执行 CPU密集型工作时，会将任务发给进程池。然后进程池会在另外一个进程中启动一个单独的Python 解释器来工作，这样就不会受限于 GIL。

也可以协程来代替多线程。协程本质上是一个线程内函数间暂停和切换，这样可以避免线程间切换的消耗，可以提高效率。

2.线程

        进程只是一个资源单位；线程才是真正的执行单位。线程也就是代码的执行过程！线程就是一条流水线工作过程，一个进程内至少有一个线程(可以有多个线程)。

2.1.1线程的创建

构造方法：

Thread(group=None, target=None, name=None, args=(), kwargs={})

• group: 线程组，目前还没有实现，库引用中提示必须是None；
• target: 要执行的方法；
• name: 线程名；
• args/kwargs: 要传入方法的参数。

实例方法：

• isAlive(): 返回线程是否在运行。
• get/setName(name): 获取/设置线程名。
• is/setDaemon(bool): 获取/设置是否守护线程。初始值从创建该线程的线程继承。当没有非守护线程仍在运行时，程序将终止。
• start(): 启动线程。
• join([timeout]): 阻塞当前上下文环境的线程，直到调用此方法的线程终止或到达指定的timeout（可选参数）

import threading
import time

def get_url1():
    print("get_url1 start")
    time.sleep(3)
    print("get_url1 done")

def get_url2():
    print("get_url2 start")
    time.sleep(3)
    print("get_url2 done")

if __name__ == '__main__':
    t1 = threading.Thread(target=get_url1)
    t2 = threading.Thread(target=get_url2)
    start_time = time.time()
    t1.start()
    t2.start()
    end_time = time.time()
    print(f"cost time :{end_time-start_time}")

运行结果：

 

2.1.2 守护线程

上面的代码，如果将t1和t2都设置为守护进行的话，当主进程死了以后，他们也会死。

t1.setDaemon(daemonic=True)
t2.setDaemon(daemonic=True)

2.1.3  join阻塞

if __name__ == '__main__':
    
    '''省略前面部分代码'''
    t1.join()
    t2.join()
    end_time = time.time()
    print(f"cost time :{end_time-start_time}")

只有线程运行完成后，后面的语句才能运行。所以我们能够看到打印出来的运行时间。

2.1.4 使用类方法创建线程

由于使用方法来创建线程有一定的局限性，所以我们还可以使用类的形式来创建线程。需要重载run方法。

程序在运行的时候会自动找到 run方法。

class GetUrl1Thead(threading.Thread):
    def __init__(self,name):
        super().__init__(name=name)
    def run(self):
        print("get_url1 start")
        time.sleep(3)
        print("get_url1 done")

if __name__ == '__main__':
    t1 = GetUrl1Thead("t1")
    t1.start()
    t1.join()

2.2 线程间的通信

线程中的通信主要有两种方式：1.共享全局变量。2，使用队列。queue.Queue 对象是线程安全的，如果你深入源码取看，会发现，是基于condition实现的。

下面这个消费者和生产者模型中，用队列存放国家生产的美女。创建一个被多个线程共享的 Queue 对象，这些线程通过使用 put() 和 get() 操作来向队列中添加或者删除元素。

全局变量count作为计数，控制关闭线程。（注意，count -= 1是不安全的，实际编程中，请加锁）。

import threading
import time
import queue

q_girl_list = queue.Queue(maxsize=3)
count = 5
r = threading.Lock()

class Government(threading.Thread):

    def run(self):
        for i in range(5):
            time.sleep(2)
            q_girl_list.put(f'g美女-{i}')
            print(f'国家： 生产了美女-{i}')


class Loser(threading.Thread):

    def __init__(self, name):
        super().__init__(name=name)

    def run(self):
        global count
        while True:
            time.sleep(3)
            if count <= 0:
                break
            girl = q_girl_list.get()
            print(f"{self.name}：领到了{girl}")
            r.acquire()
            count -= 1
            r.release()

def gen_losers():
    losers = []
    for i in range(2):
        loser = Loser(name=f'屌丝男{i}')
        losers.append(loser)
    return losers


if __name__ == '__main__':

    gen_girl = Government()
    gen_girl.start()

    loser_tasks = gen_losers()
    for item in loser_tasks:
        item.start()

2.3 线程间的同步问题

2.3.1 lock和Rlock

为什么要加锁？

下面这段代码，由于 -= 和 +=  是非原子性操作（就是不能一步到位执行的，需要分能几步执行）。所以会出现线程操作不安全的情况。因此最终结果不一定是0。

total = 0

def add():
    global total
    for i in range(1000000):
        total += 1
def desc():
    global total
    for i in range(1000000):
        total -= 1
import threading
thread1 = threading.Thread(target=add)
thread2 = threading.Thread(target=desc)
thread1.start()
thread2.start()

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

 运行结果：

lock

Lock（指令锁）是可用的最低级的同步指令。Lock处于锁定状态时，不被特定的线程拥有。

• acquire(blocking=True, timeout=-1) 可以阻塞或非阻塞地获得锁。
• release() 释放一个锁。
• locked() 如果获得了锁则返回真值

将上面的进行改写：

• from threading import Lock, 
  lock = Lock()
  def add():
      #1. dosomething1
      #2. io操作
      # 1. dosomething3
      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

r = threading.Lock()
i =0
r.acquire()
r.acquire() #阻塞在这
i += 1
r.release()
r.release()
print(i)  # 这句话不会打印出来。

Rlock

由于上的阻塞，因此引入了递归锁，上面print（i）能购被打印出来。

# r = threading.Lock()
r = threading.RLock() # 用递归锁替换

2.3.2  condition

conditon是一个非常重要的知识点，因为看源码会发现，好多东西都是基于它实现的。

Condition（条件变量）通常与一个锁关联。需要在多个Contidion中共享一个锁时，可以传递一个Lock/RLock实例给构造方法，否则它将自己生成一个RLock实例。

构造方法：

Condition([lock/rlock])

实例方法：

acquire([timeout])/release(): 调用关联的锁的相应方法。

• wait([timeout]): 调用这个方法将使线程进入Condition的等待池等待通知，并释放锁。使用前线程必须已获得锁定，否则将抛出异常。
• notify(): 调用这个方法将从等待池挑选一个线程并通知，收到通知的线程将自动调用acquire()尝试获得锁定（进入锁定池）；其他线程仍然在等待池中。调用这个方法不会释放锁定。使用前线程必须已获得锁定，否则将抛出异常。
• notifyAll(): 调用这个方法将通知等待池中所有的线程，这些线程都将进入锁定池尝试获得锁定。调用这个方法不会释放锁定。使用前线程必须已获得锁定，否则将抛出异常。

import threading

con = threading.Condition()


class XiaoAi(threading.Thread):
    def run(self):
        con.acquire()
        con.wait()
        print('在')
        con.notify()
        con.wait()

        print('不知道')
        con.release()


class Loser(threading.Thread):  
    def run(self):
        con.acquire()
        print('小爱')
        con.notify()
        con.wait()

        print('小爱，你是男的女的？')
        con.notify()
        con.release()


if __name__ == '__main__':
    xiao_ai = XiaoAi()
    Loser = Loser()
    xiao_ai.start()
    Loser.start()

运行结果： 

 

2.3.3  semaphore

SemaphoreS有一个内置的计数器，每当调用acquire()时-1，调用release() 时+1。计数器不能小于0；当计数器为0时，acquire()将阻塞线程至同步锁定状态，直到其他线程调用release()。

基于这个特点，Semaphore经常用来同步一些有“访客上限”的对象，比如连接池。

BoundedSemaphore 与Semaphore的唯一区别在于前者将在调用release()时检查计数器的值是否超过了计数器的初始值，如果超过了将抛出一个异常。

构造方法：

Semaphore(value=1): value是计数器的初始值。

实例方法：

• acquire([timeout]): 请求Semaphore。如果计数器为0，将阻塞线程至同步阻塞状态；否则将计数器-1并立即返回。
• release(): 释放Semaphore，将计数器+1，如果使用BoundedSemaphore，还将进行释放次数检查。release()方法不检查线程是否已获得 Semaphore。

 模拟编写一个爬虫，每次只获取3个url：

import threading
import time

sem = threading.Semaphore(value=3)


def get_url():
    sem.acquire()
    time.sleep(1)
    print(threading.currentThread().getName())
    sem.release()


if __name__ == '__main__':

    for i in range(10):
        r = threading.Thread(target=get_url, name=f'线程{i}')
        r.start()

 

2.3.4 事件event

Event（事件）是最简单的线程通信机制之一：一个线程通知事件，其他线程等待事件。Event内置了一个初始为False的标志，当调用set()时设为True，调用clear()时重置为 False。wait()将阻塞线程至等待阻塞状态。

Event其实就是一个简化版的 Condition。

构造方法：

Event()

实例方法：

• isSet(): 当内置标志为True时返回True。
• set(): 将标志设为True，并通知所有处于等待阻塞状态的线程恢复运行状态。
• clear(): 将标志设为False。
• wait([timeout]): 如果标志为True将立即返回，否则阻塞线程至等待阻塞状态，等待其他线程调用set()。