Python基础第十七天（同步与异步,互斥锁，死锁，线程之间通讯的消息队列，threadLocal）

同步与异步

“同”字应是指协同，协助，互相配合。
同步调用就是你 喊 你朋友吃饭，你朋友在忙，你就一直在那等，等你朋友忙完了，你们一起去。
异步调用就是你 喊 你朋友吃饭 ，你朋友说知道了，待会忙完去找你，你就去做别的了。

互斥锁

from threading import Thread,Lock
import time
g=0
def hs1():
    global g
    for i in range(100000):
        l.acquire()
        g+=1
        l.release()
    print("函数1",g)
def hs2():
    global g
    for i in range(100000):
        l.acquire()
        g+=1
        l.release()
    print("函数2",g)
if __name__ == '__main__':
    l=Lock()
    t1=Thread(target=hs1)
    t2=Thread(target=hs2)
    t1.start()
    t2.start()




def hs1():
    global g
    l.acquire()
    for i in range(100000):
        g+=1
    l.release()
    print("函数1",g)

def hs2():
    global g
    l.acquire()
    for i in range(100000):
        g+=1
    l.release()
    print("函数2",g)

if __name__ == '__main__':
    l=Lock()
    t1=Thread(target=hs1)
    t2=Thread(target=hs2)
    t1.start()
    t2.start()

死锁

g = 0
def hs1():
    global g
    for i in range(100000):
        lock1.acquire()
        print("函数1锁1得到锁，请求锁2")
        time.sleep(1)
        lock2.acquire()
        print("11111")
        g += 1
        lock2.release()
        lock1.release()
    print("函数1", g)


def hs2():
    global g
    for i in range(100000):
        lock2.acquire()
        print("函数2锁2得到锁，请求锁1")
        time.sleep(1)
        lock1.acquire()
        print("22222")
        g += 1
        lock1.release()
        lock2.release()

    print("函数2", g)


if __name__ == '__main__':
    lock1 = Lock()
    lock2 = Lock()
    t1 = Thread(target=hs1)
    t2 = Thread(target=hs2)
    t1.start()
    t2.start()

线程之间通讯的消息队列

import queue
q=queue.Queue(3)
q.put(1)
q.put(2)
q.put(3)
# print("111111",q.full())
# q.put(4)
# print()
# print("结束")
while q.qsize()>0:
    print(q.get())


def produce(q,name):
    count=1
    while True:
        bz=name+"生产的包子%d"%count
        q.put(bz)
        print(bz)
        time.sleep(1)
        count+=1
def consum(q,name):
    while True:
        bz=q.get()
        print(name,"吃",bz)
if __name__ == '__main__':
    q=queue.Queue(5)
    t1=Thread(target=produce,args=(q,"张三"))
    t2=Thread(target=consum,args=(q,"李四"))
    t1.start()
    t2.start()

队列优先级

q=queue.PriorityQueue(5)#以元组加入，数字越小优先级越高
q.put((1,"香蕉"))
q.put((4,"西瓜"))
q.put((5,"橘子"))
q.put((-4,"苹果"))
while q.qsize()>0:
    print(q.get())



q=queue.LifoQueue(4)#后进先出
q.put(2)
q.put(3)
q.put(5)
while q.qsize()>0:
    print(q.get())

threadLocal

一个threadLocal变量虽然是全局变量，但每个线程都只能读写自己线程的独立副本，互不干扰。 threadLocal解决了参数在一个线程中各个函数之间互相传递问题。

from threading import Thread
import time, threading

local=threading.local()#
def hanshu1(name):
    local.name = name
    hanshu2()

def hanshu2():
    print(threading.current_thread(), local.name)


if __name__ == '__main__':
    t1 = Thread(target=hanshu1, args=("张三",), name="线程帅哥")
    t2 = Thread(target=hanshu1, args=("李四",), name="线程美女")
    t1.start()
    t2.start()