05线程2 GIL与Lock等

一、GIL(Global Interpreter Lock：全局解释器锁)
每次执行python程序，都会产生一个独立的进程。在一个python的进程内，不仅有test.py的主线程或者由该主线程开启的其他线程，还有解释器开启的垃圾回收等解释器级别的线程，总之，所有线程都运行在这一个进程内。
某个线程想要执行，必须先拿到 GIL，我们可以把 GIL 看作是“通行证”，并且在一个 Python 进程中，GIL 只有一个。
拿不到通行证的线程，就不允许进入 CPU 执行。
全局解释锁（GIL）：就是一个互斥体，只允许一个线程来控制Python解释器。

二、 GIL与Lock

GIL保护的是解释器级的数据，保护用户自己的数据则需要自己加锁处理

需要注意的点：
1.线程抢的是GIL锁，GIL锁相当于执行权限，拿到执行权限后才能拿到互斥锁Lock，
其他线程也可以抢到GIL，但如果发现Lock仍然没有被释放则阻塞，即便是拿到执行权限GIL也要立刻交出来
2.join是等待所有，即整体串行，而锁只是锁住修改共享数据的部分，即部分串行，
要想保证数据安全的根本原理在于让并发变成串行，join与互斥锁都可以实现，毫无疑问，互斥锁的部分串行效率要更高

例：多线程共享数据没有加锁

from threading import Thread
import time

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

if __name__ == '__main__':
    n = 100
    l = []
    for i in range(100):
        t = Thread(target=task,)
        l.append(t)
        t.start()
    for t in l:
        t.join()

    print('主', n) #结果为99,因为创建线程速度很快，数据没有加锁，每个线程拿到的n都是100

 

加锁解决数据共享问题，方式一

from threading import Thread,Lock
import time
def task():
    global n
    lock.acquire() #加锁,也可以用这种方式：with mutex:#加锁
    temp = n
    time.sleep(0.1)
    n = temp - 1
    lock.release() #释放锁

if __name__ == '__main__':
    lock = Lock()
    n = 100
    l = []
    for i in range(100):
        t = Thread(target=task)
        l.append(t)
        t.start()
    for t in l:
        t.join()

    print('主', n) #结果为0

方式二：这种方式：with mutex:#加锁

from threading import Thread, Lock
import time

n = 100
def task():
    global n
    with mutex:#加锁，因为线程共用的一个进程的资源，因此，用的都是同一把锁，不用把锁作为参数传进去了
        temp = n
        time.sleep(0.1)
        n = temp -1

if __name__ == '__main__':
    mutex = Lock()
    t_l = []
    for i in range(100):
        t = Thread(target=task)
        t_l.append(t)
        t.start()

    for t in t_l:
        t.join()#保证所有的子线程都执行完毕

    print('主', n)

 三、死锁与递归锁

死锁：指两个或两个以上的进程或线程在执行过程中，因争夺资源而造成的一种互相等待的现象，
若无外力作用，它们都将无法推进下去。

解决方法，递归锁，在Python中为了支持在同一线程中多次请求同一资源，python提供了可重入锁RLock。
这个RLock内部维护着一个Lock和一个counter变量，counter记录了acquire的次数，从而使得资源可以被多次require。
直到一个线程所有的acquire都被release，其他的线程才能获得资源。上面的例子如果使用RLock代替Lock，则不会发生死锁

from threading import Thread, Lock, RLock
import time

# mutexA = Lock()
# mutexB = Lock()
mutexA = mutexB = RLock()

class MyThead(Thread):
    def run(self):
        self.fun1()
        self.fun2()

    def fun1(self):
        mutexA.acquire()
        print('{}拿到A锁'.format(self.name))

        mutexB.acquire()
        print('{}拿到B锁'.format(self.name))
        mutexB.release()

        mutexA.release()

    def fun2(self):
        mutexB.acquire()
        print('{}拿到B锁'.format(self.name))
        time.sleep(1)

        mutexA.acquire()
        print('{}拿到A锁'.format(self.name))
        mutexA.release()

        mutexB.release()


if __name__ == '__main__':
    for i in range(10):
        t = MyThead()
        t.start()

 四、信号量

from threading import Thread, Semaphore, current_thread
import time, random

sm = Semaphore(5) #信号量设为5，同时最大连接数为5，同时只有5个线程可以得到Semaphore

def task():
    with sm:
        print('{} is running'.format(current_thread().getName()))
        time.sleep(random.randint(1,3))
        print('{} is done'.format(current_thread().getName()))

if __name__ == '__main__':
    for i in range(20):
        t = Thread(target=task)
        t.start()

 五、Event

对象包含一个可由线程设置的信号标志, 它允许线程等待某些事件的发生。

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

  例1：

# （1）最简单的版本
from threading import Thread, Event, current_thread
import time

e = Event()

def check():
    print('{} is checking'.format(current_thread().getName()))
    time.sleep(3)
    e.set()

def conn():
    print('{} is wait to connect Mysql'.format(current_thread().getName()))
    e.wait()
    print('{} connected Mysql'.format(current_thread().getName()))

if __name__ == '__main__':
    t1 = Thread(target=check)
    t2 = Thread(target=conn)
    t3 = Thread(target=conn,)
    t4 = Thread(target=conn,)

    t1.start()
    t2.start()
    t3.start()
    t4.start()

# (2)设置超时时间,最大连接次数
from threading import Thread, Event, current_thread
import time

e = Event()
def check():
    print('{} is checking'.format(current_thread().getName()))
    time.sleep(0.1)
    e.set()

def conn():
    count = 1 #技术，连接次数
    while not e.is_set():
        if count > 3: #如果三次连接失败，则超时
            raise TimeoutError('超时')
        print('{} is wait to connect Mysql'.format(current_thread().getName()))
        e.wait(1) # 等待时间
        count += 1

    print('{} connected Mysql'.format(current_thread().getName()))

if __name__ == '__main__':
    t1 = Thread(target=check)
    t2 = Thread(target=conn)
    t3 = Thread(target=conn,)
    t4 = Thread(target=conn,)

    t1.start()
    t2.start()
    t3.start()
    t4.start()

# (3)设置超时时间,最大连接次数，循环的另一个写法
from threading import Thread, Event, current_thread
import time

e = Event()
def check():
    print('{} is checking'.format(current_thread().getName()))
    # time.sleep(0.0001)
    e.set()

def conn():
    count = 1#计数，连接次数
    while count < 4:
        print('{} is wait to connect Mysql'.format(current_thread().getName()))#这两句必须要放前面
        e.wait(1)  # 等待时间
        if e.is_set():#此时e为TRUE,说明可以连接
            print('{} connected Mysql'.format(current_thread().getName()))
            break
        count += 1
    else:
        raise TimeoutError('超时')


if __name__ == '__main__':
    t1 = Thread(target=check)
    t2 = Thread(target=conn)
    t3 = Thread(target=conn,)
    t4 = Thread(target=conn,)

    t1.start()
    t2.start()
    t3.start()
    t4.start()

 例2：红绿灯

import time, random
from threading import Thread, Event, current_thread

e = Event()

def f1():
    while True:
        e.clear()
        print('红灯，等2秒')
        time.sleep(2)

        e.set()
        print('绿灯，持续2秒')
        time.sleep(2)

def f2():
    while True:
        if e.is_set():
            print('{} 过马路'.format(current_thread().getName()))
            break
        else:
            print('{}等待'.format(current_thread().getName()))
            e.wait()

if __name__ == '__main__':
    Thread(target=f1).start()
    while True:
        time.sleep(random.randint(1,5))
        Thread(target=f2).start()

 六、定时器:指定n秒后执行

from threading import Timer

def hello(name):
    print('hello {}'.format(name))

t = Timer(1, hello, args=('cc',)) #指定1秒后执行
t.start()

七、线程Queue

queue队列 ：使用import queue，用法与进程Queue一样

# (1)q=queue.Queue()队列：先进先出
import queue

q = queue.Queue()
q.put(1)
q.put(2)
q.put(3)

print(q.get())
print(q.get())
print(q.get())

# (2)q = queue.LifoQueue(),堆栈，后进先出
import queue
q = queue.LifoQueue()
q.put(1)
q.put(2)
q.put(3)

print(q.get())
print(q.get())
print(q.get())

# (3)q = queue.PriorityQueue(),优先级队列
import queue
q = queue.PriorityQueue()
q.put((20, 1))
q.put((30, 2))
q.put((10, 3))

print(q.get())
print(q.get())
print(q.get())