线程之全局解释器锁加一些了解知识点

---恢复内容开始---

1.GIL全局解释器锁

2.GIL与普通的互斥锁

3.死锁

4.信号量

5.event事件

6.线程q队列

7.补充 基于TCP使用线程实现高并发

一.GIL全局解释器锁

GIL jaosn总结

    TCP服务端实现并发
        1.将不同的功能尽量拆分成不同的函数
            拆分出来的功能可以被多个地方使用
        
        1.将连接循环和通信循环拆分成不同的函数
        2.将通信循环做成多线程
        

    GIL(全局解释器锁)
    在CPython解释器才有GIL的概念，不是python的特点
    GIL也是一把互斥锁
        将并发变成串行 牺牲了效率但是提高了数据的安全
        ps:
            1.针对不同的数据 应该使用不同的锁去处理
            2.自己不要轻易的处理锁的问题 哪怕你知道acquire和release
            当业务逻辑稍微复杂的一点情况下 极容易造成死锁
    CPython中的GIL的存在是因为python的内存管理不是线程安全的
    
    内存管理
        引用计数:值与变量的绑定关系的个数
        标记清除:当内存快要满的时候 会自动停止程序的运行 检测所有的变量与值的绑定关系
                给没有绑定关系的值打上标记，最后一次性清除
        分代回收:(垃圾回收机制也是需要消耗资源的，而正常一个程序的运行内部会使用到很多变量与值
        并且有一部分类似于常量，减少垃圾回收消耗的时间，应该对变量与值的绑定关系做一个分类
        )        新生代(5S)》》》青春代(10s)》》》老年代(20s)
                垃圾回收机制扫描一定次数发现关系还在，会将该对关系移至下一代
                随着代数的递增 扫描频率是降低的
    

    同一个进程下的多个线程能否同时运行
    GIL类似于是加在解释器上面的一把锁

什么是GIL：首先来看看官方的解释

  在CPython中，这个全局解释器锁，也称之为GIL，是一个互斥锁，

防止多个线程在同一个时间执行Python字节码，这个锁是非常正要的，

因为CPython的内存管理非线程安全的，很多其他的特性依赖于GIL，

所以即使他影响了程序的效率也无法将其直接去除

总结：在CPython中，GIL会把线程的并行变成串行，导致效率降低

PS：需要知道的是，解释器并不只有CPython，还有PyPy，JPython等等。

GIL也仅存在于CPython中，这并不是python这门语言的问题，而是CPython解释器的问题

2.GIL带来的问题：

首先必须明确执行一个py文件,分为三个步骤

1. 从硬盘加载Python解释器到内存

2. 从硬盘加载py文件到内存

3. 解释器解析py文件内容，交给CPU执行

其次需要明确的是每当执行一个py文件，就会立即启动一个python解释器，

当执行test.py时其内存结构如下：

GIL，叫做全局解释器锁，加到了解释器上，并且是一把互斥锁，那么这把锁对应用程序到底有什么影响？

这就需要知道解释器的作用，以及解释器与应用程序代码之间的关系

py文件中的内容本质都是字符串，只有在被解释器解释时，才具备语法意义，解释器会将py代码翻译为当前系统支持的指令交给系统执行。

开启子线程时，给子线程指定了一个target表示该子线程要处理的任务即要执行的代码。代码要执行则必须交由解释器，即多个线程之间就需要共享解释器，为了避免共享带来的数据竞争问题，于是就给解释器加上了互斥锁！

由于互斥锁的特性，程序串行，保证数据安全，降低执行效率，GIL将使得程序整体效率降低！

3.那么为什么需要GIL锁：

GIL与GC

在使用Python中进行编程时，程序员无需参与内存的管理工作，这是因为Python有自带的内存管理机制，简称GC。那么GC与GIL有什么关联？

要搞清楚这个问题，需先了解GC的工作原理，Python中内存管理使用的是引用计数，每个数会被加上一个整型的计数器，表示这个数据被引用的次数，当这个整数变为0时则表示该数据已经没有人使用，成了垃圾数据。

当内存占用达到某个阈值时，GC会将其他线程挂起，然后执行垃圾清理操作，垃圾清理也是一串代码，也就需要一条线程来执行。

示例代码：

from threading import Thread
def task():
a = 10
print(a)

# 开启三个子线程执行task函数
Thread(target=task).start()
Thread(target=task).start()
Thread(target=task).start()

上述代码的内存结构如下：

通过上图可以看出，GC与其他线程都在竞争解释器的执行权，而CPU何时切换，以及切换到哪个线程都是无法预支的，这样一来就造成了竞争问题，假设线程1正在定义变量a=10，而定义变量第一步会先到到内存中申请空间把10存进去，第二步将10的内存地址与变量名a进行绑定，如果在执行完第一步后，CPU切换到了GC线程，GC线程发现10的地址引用计数为0则将其当成垃圾进行了清理，等CPU再次切换到线程1时，刚刚保存的数据10已经被清理掉了，导致无法正常定义变量。

当然其他一些涉及到内存的操作同样可能产生问题问题，为了避免GC与其他线程竞争解释器带来的问题，CPython简单粗暴的给解释器加了互斥锁，如下图所示：

有了GIL后，多个线程不可能在同一时间使用解释器，从而保证了解释器的数据安全

GIL的加锁时机：在调用解释器时立即加锁

解锁时机：
　　当前线程遇到了IO时释放

　　当前线程执行时间超过设定值时释放

GIL锁有优点也有缺点：
优点：

　　保证了数据的安全

缺点：
　　互斥锁的特性使得多线程无法并行

研究python的多线程是否有用需要分情况讨论
四个任务 计算密集型的  10s
单核情况下
    开线程更省资源
多核情况下
    开进程 10s
    开线程 40s

四个任务 IO密集型的  
单核情况下
    开线程更节省资源
多核情况下
    开线程更节省资源

案例：计算密集型

from multiprocessing import Process
from threading import Thread
import os,time
def work():
    res=0
    for i in range(100000000):
        res*=i


if __name__ == '__main__':
    l=[]
    print(os.cpu_count())  # 本机为6核
    start=time.time()
    for i in range(6):
        # p=Process(target=work) #耗时  4.732933044433594
        p=Thread(target=work) #耗时 22.83087730407715
        l.append(p)
        p.start()
    for p in l:
        p.join()
    stop=time.time()
    print('run time is %s' %(stop-start))

案例：IO密集型

from multiprocessing import Process

import os,time
def work():
    time.sleep(2)

if __name__ == '__main__':
    l=[]
    print(os.cpu_count()) #本机为6核
    start=time.time()
    for i in range(4000):
        p=Process(target=work) #耗时9.001083612442017s多,大部分时间耗费在创建进程上
        # p=Thread(target=work) #耗时2.051966667175293s多
        l.append(p)
        p.start()
    for p in l:
        p.join()
    stop=time.time()
    print('run time is %s' %(stop-start))

总结：

python的多线程到底有没有用
需要看情况而定  并且肯定是有用的
多进程+多线程配合使用

二.GIL与普通的互斥锁区别

GIL保护的是解释器级别的数据安全，比如对象的引用计数，垃圾分代数据等等，具体参考垃圾回收机制详解。

对于程序中自己定义的数据则没有任何的保护效果，这一点在没有介绍GIL前我们就已经知道了，所以当程序中出现了共享自定义的数据时就要自己加锁，如下例：

案例：向一下代码那样，还是需要加互斥所的

from threading import Thread
import time

n = 100


def task():
    global n
    tmp = n
    time.sleep(1)
    n = tmp -1

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)

三.死锁

死锁问题
当程序出现了不止一把锁,分别被不同的线程持有, 有一个资源 要想使用必须同时具备两把锁
这时候程序就会进程无限卡死状态 ,这就称之为死锁

 案例：

案例：

from threading import Thread RLock
import time

mutexA = Lock()
mutexB = Lock()



class MyThread(Thread):
    def run(self):  # 创建线程自动触发run方法 run方法内调用func1 func2相当于也是自动触发
        self.func1()
        self.func2()

    def func1(self):
        mutexA.acquire()
        print('%s抢到了A锁'%self.name)  # self.name等价于current_thread().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(10):
    t = MyThread()
    t.start()

这样就会产生死锁现象：解释
首先执行的是func1然后线程1抢到A锁，其他九个线程需要的需要等待A锁被释放，
线程1不会释放A锁，紧接着就会抢B锁，B锁是没有人抢的，所以直接就可以拿到B锁，
然后释放B锁，紧接着释放A锁，那么其他九个在等待的线程看到A锁被线程1释放了，
他们就会立马区抢，那么线程1已经区执行func2了，因为其他九个线程都在func1哪里抢，
线程1直接就可以抢到B锁，然后线程1会进入阻塞状态1秒，但是线程1还持有者B锁，
func1里面的线程也开始抢B锁了，1秒阻塞状态过去，线程1也需要抢A锁了，
但是A锁被func1里面的线程持有，这样就会产生我要你的A锁，你要我的B锁，
但是都给不了，就会卡住

补充知识点：

Rlock 称之为递归锁或者可重入锁

与Lock唯一的区别: Rlock同一线程可以多次执行acquire 但是执行几次acquire就应该对应release几次 如果一个线程已经执行过acquire 其他线程将无法执行acquire

 案例：

from threading import Thread,Lock,current_thread,RLock
import time
"""
Rlock可以被第一个抢到锁的人连续的acquire和release
每acquire一次锁身上的计数加1
每release一次锁身上的计数减1
只要锁的计数不为0 其他人都不能抢

"""
# mutexA = Lock()
# mutexB = Lock()
mutexA = mutexB = RLock()  # A B现在是同一把锁


class MyThread(Thread):
    def run(self):  # 创建线程自动触发run方法 run方法内调用func1 func2相当于也是自动触发
        self.func1()
        self.func2()

    def func1(self):
        mutexA.acquire()
        print('%s抢到了A锁'%self.name)  # self.name等价于current_thread().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(10):
    t = MyThread()
    t.start()

四.信号量

可以现在被锁定的代码 同时可以被多少线程并发访问
互斥锁： 锁住一个马桶 同时只能有一个
信号量： 锁住一个公共厕所 同时可以来一堆人

用途: 仅用于控制并发访问 并不能防止并发修改造成的问题

案例：

from threading import Semaphore,Thread
import time
import random

sm = Semaphore(5)  # 造了一个含有五个的坑位的公共厕所

def task(name):
    sm.acquire()
    print('%s占了一个坑位'%name)
    time.sleep(random.randint(1,3))
    sm.release()

for i in range(40):
    t = Thread(target=task,args=(i,))
    t.start()

五.event事件

什么是事件

事件表示在某个时间发生了某个事情的通知信号，用于线程间协同工作。

因为不同线程之间是独立运行的状态不可预测，所以一个线程与另一个线程间的数据是不同步的，当一个线程需要利用另一个线程的状态来确定自己的下一步操作时，就必须保持线程间数据的同步，Event就可以实现线程间同步

可用的一些方法：

event.isSet()：返回event的状态值；
event.wait()：将阻塞线程；知道event的状态为True
event.set()： 设置event的状态值为True，所有阻塞池的线程激活进入就绪状态， 等待操作系统调度；
event.clear()：恢复event的状态值为False

案例：

from threading import Event,Thread
import time

# 先生成一个event对象
e = Event()


def light():
    print('红灯正亮着')
    time.sleep(3)
    e.set()  # 发信号
    print('绿灯亮了')

def car(name):
    print('%s正在等红灯'%name)
    e.wait()  # 等待信号
    print('%s加油门飙车了'%name)

t = Thread(target=light)
t.start()

for i in range(10):
    t = Thread(target=car,args=('伞兵%s'%i,))
    t.start()

 六.线程q对列

同一个进程下的多个线程本来就是数据共享 为什么还要用队列

因为队列是管道+锁  使用队列你就不需要自己手动操作锁的问题 

因为锁操作的不好极容易产生死锁现象

1.Queue 先进先出队列

与多进程中的Queue使用方式完全相同，区别仅仅是不能被多进程共享。

 案例：

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

2.LifoQueue 后进先出队列

该队列可以模拟堆栈，实现先进后出，后进先出

 案例：

lq = LifoQueue()

lq.put(1)
lq.put(2)
lq.put(3)

print(lq.get())
print(lq.get())
print(lq.get())

3.PriorityQueue 优先级队列

该队列可以为每个元素指定一个优先级，这个优先级可以是数字，字符串或其他类型，但是必须是可以比较大小的类型，取出数据时会按照从小到大的顺序取出

 案例：

pq = PriorityQueue()
# 数字优先级
pq.put((10,"a"))
pq.put((11,"a"))
pq.put((-11111,"a"))

print(pq.get())
print(pq.get())
print(pq.get())
# 字符串优先级
pq.put(("b","a"))
pq.put(("c","a"))
pq.put(("a","a"))

print(pq.get())
print(pq.get())
print(pq.get())

 补充：如何解决基于TCP的高并发

server：

import socket
from threading import Thread

"""
服务端
    1.要有固定的IP和PORT
    2.24小时不间断提供服务
    3.能够支持并发
"""

server = socket.socket()
server.bind(('127.0.0.1',8080))
server.listen(5)


def talk(conn):
    while True:
        try:
            data = conn.recv(1024)
            if len(data) == 0:break
            print(data.decode('utf-8'))
            conn.send(data.upper())
        except ConnectionResetError as e:
            print(e)
            break
    conn.close()

while True:
    conn, addr = server.accept()  # 监听 等待客户端的连接  阻塞态
    print(addr)
    t = Thread(target=talk,args=(conn,))
    t.start()

client：

import socket


client = socket.socket()
client.connect(('127.0.0.1',8080))

while True:
    client.send(b'hello')
    data = client.recv(1024)
    print(data.decode('utf-8'))