# 方法包裝-啟動(dòng)多線程
from threading import Thread 
from time import sleep, time 
def func1(name): 
    print("Threading:{} start".format(name)) 
    sleep(3) 
    print("Threading:{} end".format(name)) 
if __name__ == '__main__': 
    # 開始時(shí)間 
    start = time() 
    # 創(chuàng)建線程列表 
    t_list = [] 
    # 循環(huán)創(chuàng)建線程 
    for i in range(10): 
        t = Thread(target=func1, args=('t{}'.format(i),)) 
        t.start() 
        t_list.append(t) 
    # 等待線程結(jié)束 
    for t in t_list: 
        t.join() 
    # 計(jì)算使用時(shí)間 
    end = time() - start 
    print(end)

# 類包裝-啟動(dòng)多線程 
from threading import Thread 
from time import sleep, time 
class MyThread(Thread): 
    def __init__(self,name): 
        Thread.__init__(self) 
        self.name =name 
    def run(self): 
        print("Threading:{} start".format(self.name)) 
        sleep(3) 
        print("Threading:{} end".format(self.name)) 
if __name__ == '__main__': 
    # 開始時(shí)間 
    start = time() 
    # 創(chuàng)建線程列表 
    t_list = [] 
    # 循環(huán)創(chuàng)建線程 
    for i in range(10): 
        t = MyThread('t{}'.format(i)) 
        t.start() 
        t_list.append(t) 
    # 等待線程結(jié)束 
    for t in t_list: 
        t.join() 
    # 計(jì)算使用時(shí)間 
    end = time() - start 
    print(end)

# 類包裝-啟動(dòng)多線程 
from threading import Thread 
from time import sleep, time 
class MyThread(Thread): 
    def __init__(self,name): 
        Thread.__init__(self) 
        self.name =name 
    def run(self): 
        print("Threading:{} start".format(self.name)) 
        sleep(3) 
        print("Threading:{} end".format(self.name)) 
if __name__ == '__main__': 
    # 開始時(shí)間 
    start = time() 
    # 循環(huán)創(chuàng)建線程 
    for i in range(10): 
        t = MyThread('t{}'.format(i)) 
        t.setDaemon(True)
        t.start() 
    # 計(jì)算使用時(shí)間 
    end = time() - start 
    print(end)

from threading import Thread 
def func1(name): 
    print('Threading:{} start'.format(name)) 
    global num 
    for i in range(50000000): # 有問(wèn)題 
    #for i in range(5000): # 無(wú)問(wèn)題 
        num += 1 
    print('Threading:{} end num={}'.format(name, num))
if __name__ == '__main__': 
    num =0 
    # 創(chuàng)建線程列表 
    t_list = [] 
    # 循環(huán)創(chuàng)建線程 
    for i in range(5): 
        t = Thread(target=func1, args=('t{}'.format(i),)) 
        t.start() 
        t_list.append(t) 
    # 等待線程結(jié)束 
    for t in t_list: 
        t.join()

from threading import Thread,Lock 
def func1(name):
    # 獲取鎖
    lock.acquire()
    with lock:
        global count
        for i in range(100000):
            count += 1
    # 釋放鎖 
    lock.release()
if __name__ == "__main__":
    count = 0
    t_list = []
    # 創(chuàng)建鎖對(duì)象
    lock = Lock()
    for i in range(10):
        t = Thread(target=func1,args=(f't{i+1}',))
        t.start()
        t_list.append(t)
    for t in t_list:
        t.join()
    print(count)

from threading import Thread, Lock #Lock 鎖 同步鎖 互斥鎖
from time import sleep 
def fun1(): 
    lock1.acquire() 
    print('fun1 拿到鍵盤') 
    sleep(2) 
    lock2.acquire() 
    print('fun1 拿到鼠標(biāo)') 
    lock2.release() 
    print('fun1 釋放鼠標(biāo)') 
    lock1.release() 
    print('fun1 釋放鍵盤') 
def fun2(): 
    lock2.acquire() 
    print('fun2 拿到鼠標(biāo)') 
    lock1.acquire() 
    print('fun2 拿到鍵盤') 
    lock1.release() 
    print('fun2 釋放鍵盤') 
    lock2.release() 
    print('fun2 釋放鼠標(biāo)') 
if __name__ == '__main__':
    lock1 = Lock() 
    lock2 = Lock() 
    t1 = Thread(target=fun1) 
    t2 = Thread(target=fun2) 
    t1.start() 
    t2.start()

from threading import RLock
'''
Lock 鎖 同步鎖 互斥鎖
RLock 遞歸鎖
'''
def func1():
    lock.acquire()
    print('func1獲取鎖')
    func2()
    lock.release()
    print('func1釋放鎖')
def func2():
    lock.acquire()
    print('func2獲取鎖')
    lock.release()
    print('func2釋放鎖')
def func3():
    func1()
    func2()
if __name__ == "__main__":
    #lock = Lock()  會(huì)產(chǎn)生錯(cuò)誤 
    lock = RLock()
    func3()

from time import sleep
from threading import Thread
from threading import BoundedSemaphore
def index(num):
    lock.acquire()
    print(f'第{num}個(gè)人乘坐??！')
    sleep(2)
    lock.release()
if __name__ == "__main__":
    lock = BoundedSemaphore(3)
    for i in range(10):
        t = Thread(target=index,args=(f'{i+1}',))
        t.start()

from threading import Thread
from queue import Queue
from time import sleep
def producer():
    num = 1
    while True:
        print(f'生產(chǎn)了{(lán)num}號(hào)皮卡丘')
        qe.put(f'{num}號(hào)皮卡丘')
        num += 1 
        sleep(1)
def consumer():
    print('購(gòu)買了{(lán)}'.format(qe.get()))
    sleep(2)
if __name__ == "__main__":
    # 共享數(shù)據(jù)的容器
    qe= Queue(maxsize=5)
    # 創(chuàng)建生產(chǎn)者線程
    t1 = Thread(target = producer)
    # 創(chuàng)建消費(fèi)者線程
    t2 = Thread(target = consumer)
    # 創(chuàng)建消費(fèi)者線程
    t3 = Thread(target = consumer)
    # 開始工作
    t1.start()
    t2.start()
    t3.start()