基于线程和进程的深入研究

cpython中的GIL解释器锁

基于对GIL解释器锁的问题，我们先来看一下官方文档给出的解释：

"""

      In CPython, the global interpreter lock, or GIL, is a mutex that prevents multiple
native threads from executing Python bytecodes at once. This lock is necessary mainly
because CPython’s memory management is not thread-safe. (However, since the GIL
exists, other features have grown to depend on the guarantees that it enforces.)

"""
我们能提炼出以下几点：
1.GIL是一个互斥锁:保证数据的安全(以牺牲效率来换取数据的安全)
2.阻止同一个进程内多个线程同时执行(不能并行但是能够实现并发)
3.并发:看起来像同时进行的
4.GIL全局解释器存在的原因是因为Cpython解释器的内存管理不是线程安全的

 

这里不同于pycharm的垃圾回收机制：1.引用计数 2.标记清除 3.分代回收

也就是说，在同一进程下的多个线程是不可能实现并行的但是可以实现并发；相反多个进程下的线程是可以实现并行的。

基于这点，你会问：我曹，python连多线程抖实现不了，是不是太low了啊？我的回答是：不是的。对于多个进程的多线程的并行实现是毋庸置疑的，在同一个进程下的并行分为两种情况：

1.基于计算密集型

    首先在单核情况下：基于计算的使用多线程较好，因为在相同的进程数下，多线程消耗的资源少。

    在多核的情况下：开四个进程可能需要10s左右，而开四个线程需要40s左右。

2.基于IO密集型

　　首先在单核情况下；多线程比较好一点

　　在多核的情况下：多线程比较好一点

1.基于计算密集型

# 导入相关的模块
from multiprocessing import Process
from theading import Thread
import time, os


# 定义计算过程
def work():
    res = 0
    for i in range(100):
        res *= i

if __name__=='__mian__':
    
    # 本机的硬件基础
    print(os.cpu_count)  # 本机的cpu核心数为4
    lis = []
    start = time.time()
    for i in range(8):
        p = Process(target = work) # 创建的线程这里不做演示，类似的
        lis.append(p)
       p.start()
    
    for i in lis:
        i.join()
    end = time.time()
    # 打印输出使用的时间
    print('use time is :%s' %(end - start))

2.基于IO的型

from multiprocessing import Process
from threading import Thread
import os, time


# def work():
#     res = 0
#     for i in range(100):
#         res += i


# 基于IO型
def sleep():
    time.sleep(3)

if __name__ == '__main__':
    lis = []
    start = time.time()
    for i in range(8):
        p = Process(target=sleep)
        # p = Thread(target=sleep)
        lis.append(p)
        p.start()
    for j in lis:
        j.join()
    end = time.time()
    print('use time is : %s' % (end - start))

GIL解释器锁和互斥锁的对比

大方面：GIL解释器锁针对的是解释器；互斥锁针对的是操作的数据。

 

from threading import Thread,Lock
import time

mutex = Lock()

n = 100

def task():
    global n
    mutex.acquire()
    tmp = n
    time.sleep(0.1)
    n = tmp - 1
    mutex.release()

t_list = []
for i in range(100):
    t = Thread(target=task)
    t.start()
    t_list.append(t)

for t in t_list:
    t.join()

print(n)

"""
对于不同的数据，要想保证安全，需要加不同的锁处理
GIL并不能保证数据的安全，它是对Cpython解释器加锁，针对的是线程
保证的是同一个进程下多个线程之间的安全
"""

 

死锁和递归锁

from threading import Thread,Lock,RLock
import time

"""
自定义锁一次acquire必须对应一次release，不能连续acquire
递归锁可以连续的acquire，每acquire一次计数加一:针对的是第一个抢到我的人
"""
import random
#
# mutexA = Lock()
# mutexB = Lock()
mutexA = mutexB = RLock()  # 抢锁之后会有一个计数 抢一次计数加一 针对的是第一个抢到我的人


class MyThead(Thread):
    def run(self):
        self.func1()
        self.func2()

    def func1(self):
        mutexA.acquire()
        print('%s 抢到A锁了'%self.name)
        mutexB.acquire()
        print('%s 抢到B锁了' % self.name)
        mutexB.release()
        print('%s 释放了B锁'%self.name)
        mutexA.release()
        print('%s 释放了A锁'%self.name)

    def func2(self):
        mutexB.acquire()
        print('%s 抢到了B锁'%self.name)
        time.sleep(1)
        mutexA.acquire()
        print('%s 抢到A锁了' % self.name)
        mutexA.release()
        print('%s 释放了A锁' % self.name)
        mutexB.release()
        print('%s 释放了B锁' % self.name)


for i in range(100):
    t = MyThead()
    t.start()

 

线程Queue

import queue

# 1.普通q
# 2.先进后出q
# 3.优先级q


# queue包含的有Queue,LifoQueue,PriorityQueue

# q=queue.Queue(3)
# q.put(1)
# q.put(2)
# q.put(3)
# print(q.get())
# print(q.get())
# print(q.get())

# q = queue.LifoQueue(5)
# q.put(1)
# q.put(2)
# q.put(3)
# q.put(4)
# print(q.get())



# 优先级q
# q = queue.PriorityQueue()
# q.put((10,'a'))
# q.put((-1,'b'))
# q.put((100,'c'))
# print(q.get())
# print(q.get())
# print(q.get())

信号量

 

from threading import Thread,Semaphore
import time
import random
sm = Semaphore(5)  # 五个厕所五把锁
# 跟你普通的互斥锁区别在于，普通的互斥锁是独立卫生间，所有人抢一把锁
# 信号量 公共卫生间 有多个坑，所有人抢多把锁



def task(name):
    sm.acquire()
    print('%s正在蹲坑'%name)
    # 模拟蹲坑耗时
    time.sleep(random.randint(1,5))
    sm.release()


if __name__ == '__main__':
    for i in range(20):
        t = Thread(target=task,args=('伞兵%s号'%i,))
        t.start()