python的多线程+GIL全局解释器锁+其他LOCK

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

python的多线程实际上只有一个线程。

为了让各个线程能够平均利用CPU时间，python会计算当前已执行的微代码数量，达到一定阈值后就强制释放GIL。而这时也会触发一次操作系统的线程调度（当然是否真正进行上下文切换由操作系统自主决定）。

 

GIL全局解释器锁： 保证同一时间只有一个线程得到数据并且只有一个线程执行，但是cpu调度时间到了以后，第一个线程无论是否完成均程等待状态（若未执行完毕，数据放入寄存器中）下一线程得到的依旧是原始的公共数据。

用户级lock:保证同一时间只有一个线程在修改数据。（可以避免几个线程同时对公共原始数据进行修改，提高线程效率）

为公共数据Lock:一个线程修改后，释放，下一进程才可再次进行修改。

 

RLock（递归锁）:在一个大锁中还要再包含子锁

import threading, time


def run1():
    print("grab the first part data")
    lock.acquire()
    global num
    num += 1
    lock.release()
    return num


def run2():
    print("grab the second part data")
    lock.acquire()
    global num2
    num2 += 1
    lock.release()
    return num2


def run3():
    lock.acquire()
    res = run1()
    print('--------between run1 and run2-----')
    res2 = run2()
    lock.release()
    print(res, res2)


# if __name__ == '__main__':

num, num2 = 0, 0
lock = threading.RLock()
for i in range(10):
    t = threading.Thread(target=run3)
    t.start()

while threading.active_count() != 1:
    print(threading.active_count())
else:
    print('----all threads done---')
    print(num, num2)

线程锁(互斥锁Mutex)

信号量：和单个锁的区别是信号量有多个锁

import threading, time

# 信号量就是多个锁
def run(n):
    semaphore.acquire()#信号量获取
    time.sleep(1)
    print("run the thread: %s\n" % n)
    semaphore.release() # 信号量释放


if __name__ == '__main__':

    num = 0
    semaphore = threading.BoundedSemaphore(5)  # 最多允许5个线程同时运行
    for i in range(20):
        t = threading.Thread(target=run, args=(i,))
        t.start()

while threading.active_count() != 1:
    pass  # print threading.active_count()
else:
    print('----all threads done---')
    print(num)

 

事件Event:实现红绿灯

概念&涉及知识点：

事件是一个简单的同步对象;代表一个内部标志，线程可以等待设置标志，或者自己设置或清除标志。

＃客户端线程可以等待设置标志      event.wait（）

#a服务器线程可以设置或重置它     event.set（）  event.clear（）

如果设置了标志，则wait方法不会执行任何操作。
如果该标志被清除，则等待将被阻塞，直到它再次被设置为止。
任意数量的线程都可以等待同一事件。

import time
import  threading

event = threading.Event()
def Lighter():
    count = 0
    event.set()
    while True:
        if count >5 and count <10: # 改成红灯
            #无标志位会显示等待，有标志位是通行。  wait是通行
            event.clear() #清空标志位
            print('\033[41;1mred light \033[0m')
        elif count >10:
            event.set() # 设置标志位，变绿灯
            count = 0
        else:
            print('\033[42;1mgreen light \033[0m')

        time.sleep(1)
        count += 1

def car(name):
    while True:
        if event.is_set(): #代表绿灯
            time.sleep(1)
            print('[%s] running '%name)
        else:
            print('[%s] sees red light ,waiting '%name)
            event.wait()
            print('\033[34;1m[%s] green light is on ,start going \033[0m'%name)

light = threading.Thread(target=Lighter,)
light.start()

car1 = threading.Thread(target=car,args=('Car1',))
car1.start()

 

队列：使程序之间实现松耦合，提高处理效率。

两种模式：

 FIFO = first in first out

 LIFO = last in first out

队列和列表的区别：

队列：数据取出后，队列中就没有此数据了。

列表；数据取出进行操作，但是列表中仍旧有原数据。

 

生产者与消费者模式（做解耦）：

import threading,time

import queue

q = queue.Queue()
q.maxsize = 10

def Producer(name):
    count = 1
    #for i in range(10):
    while True:
        q.put("骨头%s" %count) #%i)
        print("生产了骨头",count)
        count += 1
        time.sleep(2)


def Consumer(name):
    while True:
        print("[%s]取到[%s]并且吃了它" %(name, q.get()))
        time.sleep(1)

p = threading.Thread(target=Producer, args=("lex",))
c1 = threading.Thread(target=Consumer, args=("chen",))
c2 = threading.Thread(target=Consumer, args=("wang",))

p.start()
c1.start()
c2.start()