import threading
import time
 
def saySorry():
  print("親愛(ài)的，我錯(cuò)了，我能吃飯了嗎？")
  time.sleep(5)
 
if __name__ == "__main__":
    start_time1 = time.time()
    for i in range(5):
      t = threading.Thread(target=saySorry)
      t.start() #啟動(dòng)線程，即讓線程開(kāi)始執(zhí)行
    end_time1 = time.time()
    print(end_time1 - start_time1)
 
    start_time2 = time.time()
    for i in range(5):
        t = saySorry()
 
    end_time2 = time.time()
    print(end_time2 - start_time2)

import threading
from time import sleep,ctime
 
def sing():
  for i in range(3):
    print("正在唱歌...%d"%i)
    sleep(1)
 
def dance():
  for i in range(3):
    print("正在跳舞...%d"%i)
    sleep(1)
 
if __name__ == '__main__':
  print('---開(kāi)始---:%s'%ctime())
 
  t1 = threading.Thread(target=sing)
  t2 = threading.Thread(target=dance)
 
  t1.start()
  t2.start()
 
  # sleep(5) # 屏蔽此行代碼，試試看，程序是否會(huì)立馬結(jié)束？
  print('---結(jié)束---:%s'%ctime())

import threading
from time import sleep,ctime
 
def sing():
  for i in range(3):
    print("正在唱歌...%d"%i)
    sleep(1)
 
def dance():
  for i in range(3):
    print("正在跳舞...%d"%i)
    sleep(1)
 
if __name__ == '__main__':
  print('---開(kāi)始---:%s'%ctime())
 
  t1 = threading.Thread(target=sing)
  t2 = threading.Thread(target=dance)
 
  t1.start()
  t2.start()
 
  while True:
    length = len(threading.enumerate())
    print('當(dāng)前運(yùn)行的線程數(shù)為：%d'%length)
    if length<=1:
      break
 
    sleep(0.5)

import threading
import time
 
 
def sing():
    for i in range(5):
        print("我是sing")
        time.sleep(1)
 
 
def dance():
    for i in range(5):
        print("我是dance")
        time.sleep(1)
 
 
if __name__ == '__main__':
    # 創(chuàng)建兩個(gè)子線程
    t1 = threading.Thread(target=sing)
    t2 = threading.Thread(target=dance)
    # 啟動(dòng)子線程
    t1.start()
    t2.start()

import threading
import time
 
def test():
  for i in range(7):
    print("test is run:", i)
    time.sleep(1)
 
if __name__ == '__main__':
  # 創(chuàng)建子線程
  t1 = threading.Thread(target=test)
  # 啟動(dòng)子線程
  t1.start()
  # 休眠2秒
  time.sleep(2)
 
  print("我 OVER 了")
  # 退出
  exit()

import threading
import time
 
def test():
  for i in range(7):
    print("test is run:", i)
    time.sleep(1)
 
if __name__ == '__main__':
  # 創(chuàng)建子線程
  t1 = threading.Thread(target=test)
  #設(shè)置線程保護(hù)
  t1.setDaemon(True)
  # 啟動(dòng)子線程
  t1.start()
  # 休眠2秒
  time.sleep(2)
 
  print("我 OVER 了")
  # 退出
  exit()

import threading
from threading import Lock,Thread
import time,os
 
 
'''
                                      python多線程詳解
      什么是線程？
      線程也叫輕量級(jí)進(jìn)程，是操作系統(tǒng)能夠進(jìn)行運(yùn)算調(diào)度的最小單位，它被包涵在進(jìn)程之中，是進(jìn)程中的實(shí)際運(yùn)作單位。
      線程自己不擁有系統(tǒng)資源，只擁有一點(diǎn)兒在運(yùn)行中必不可少的資源，但它可與同屬一個(gè)進(jìn)程的其他線程共享進(jìn)程所
      擁有的全部資源。一個(gè)線程可以創(chuàng)建和撤銷另一個(gè)線程，同一個(gè)進(jìn)程中的多個(gè)線程之間可以并發(fā)執(zhí)行
'''
 
'''
    為什么要使用多線程？
    線程在程序中是獨(dú)立的、并發(fā)的執(zhí)行流。與分隔的進(jìn)程相比，進(jìn)程中線程之間的隔離程度要小，它們共享內(nèi)存、文件句柄
    和其他進(jìn)程應(yīng)有的狀態(tài)。
    因?yàn)榫€程的劃分尺度小于進(jìn)程，使得多線程程序的并發(fā)性高。進(jìn)程在執(zhí)行過(guò)程之中擁有獨(dú)立的內(nèi)存單元，而多個(gè)線程共享
    內(nèi)存，從而極大的提升了程序的運(yùn)行效率。
    線程比進(jìn)程具有更高的性能，這是由于同一個(gè)進(jìn)程中的線程都有共性，多個(gè)線程共享一個(gè)進(jìn)程的虛擬空間。線程的共享環(huán)境
    包括進(jìn)程代碼段、進(jìn)程的共有數(shù)據(jù)等，利用這些共享的數(shù)據(jù)，線程之間很容易實(shí)現(xiàn)通信。
    操作系統(tǒng)在創(chuàng)建進(jìn)程時(shí)，必須為改進(jìn)程分配獨(dú)立的內(nèi)存空間，并分配大量的相關(guān)資源，但創(chuàng)建線程則簡(jiǎn)單得多。因此，使用多線程
    來(lái)實(shí)現(xiàn)并發(fā)比使用多進(jìn)程的性能高得要多。
'''
 
'''
    總結(jié)起來(lái)，使用多線程編程具有如下幾個(gè)優(yōu)點(diǎn)：
    進(jìn)程之間不能共享內(nèi)存，但線程之間共享內(nèi)存非常容易。
    操作系統(tǒng)在創(chuàng)建進(jìn)程時(shí)，需要為該進(jìn)程重新分配系統(tǒng)資源，但創(chuàng)建線程的代價(jià)則小得多。因此使用多線程來(lái)實(shí)現(xiàn)多任務(wù)并發(fā)執(zhí)行比使用多進(jìn)程的效率高
    python語(yǔ)言內(nèi)置了多線程功能支持，而不是單純地作為底層操作系統(tǒng)的調(diào)度方式，從而簡(jiǎn)化了python的多線程編程。
'''
 
 
'''
    普通創(chuàng)建方式
'''
# def run(n):
#     print('task',n)
#     time.sleep(1)
#     print('2s')
#     time.sleep(1)
#     print('1s')
#     time.sleep(1)
#     print('0s')
#     time.sleep(1)
#
# if __name__ == '__main__':
#     t1 = threading.Thread(target=run,args=('t1',))     # target是要執(zhí)行的函數(shù)名（不是函數(shù)），args是函數(shù)對(duì)應(yīng)的參數(shù)，以元組的形式存在
#     t2 = threading.Thread(target=run,args=('t2',))
#     t1.start()
#     t2.start()
 
 
'''
    自定義線程：繼承threading.Thread來(lái)定義線程類，其本質(zhì)是重構(gòu)Thread類中的run方法
'''
# class MyThread(threading.Thread):
#     def __init__(self,n):
#         super(MyThread,self).__init__()   #重構(gòu)run函數(shù)必須寫
#         self.n = n
#
#     def run(self):
#         print('task',self.n)
#         time.sleep(1)
#         print('2s')
#         time.sleep(1)
#         print('1s')
#         time.sleep(1)
#         print('0s')
#         time.sleep(1)
#
# if __name__ == '__main__':
#     t1 = MyThread('t1')
#     t2 = MyThread('t2')
#     t1.start()
#     t2.start()
 
 
'''
    守護(hù)線程
    下面這個(gè)例子，這里使用setDaemon(True)把所有的子線程都變成了主線程的守護(hù)線程，
    因此當(dāng)主線程結(jié)束后，子線程也會(huì)隨之結(jié)束，所以當(dāng)主線程結(jié)束后，整個(gè)程序就退出了。
    所謂'線程守護(hù)'，就是主線程不管該線程的執(zhí)行情況，只要是其他子線程結(jié)束且主線程執(zhí)行完畢，主線程都會(huì)關(guān)閉。也就是說(shuō):主線程不等待該守護(hù)線程的執(zhí)行完再去關(guān)閉。
'''
# def run(n):
#     print('task',n)
#     time.sleep(1)
#     print('3s')
#     time.sleep(1)
#     print('2s')
#     time.sleep(1)
#     print('1s')
#
# if __name__ == '__main__':
#     t=threading.Thread(target=run,args=('t1',))
#     t.setDaemon(True)
#     t.start()
#     print('end')
'''
    通過(guò)執(zhí)行結(jié)果可以看出，設(shè)置守護(hù)線程之后，當(dāng)主線程結(jié)束時(shí)，子線程也將立即結(jié)束，不再執(zhí)行
'''
 
'''
    主線程等待子線程結(jié)束
    為了讓守護(hù)線程執(zhí)行結(jié)束之后，主線程再結(jié)束，我們可以使用join方法，讓主線程等待子線程執(zhí)行
'''
# def run(n):
#     print('task',n)
#     time.sleep(2)
#     print('5s')
#     time.sleep(2)
#     print('3s')
#     time.sleep(2)
#     print('1s')
# if __name__ == '__main__':
#     t=threading.Thread(target=run,args=('t1',))
#     t.setDaemon(True)    #把子線程設(shè)置為守護(hù)線程，必須在start()之前設(shè)置
#     t.start()
#     t.join()     #設(shè)置主線程等待子線程結(jié)束
#     print('end')
 
 
'''
    多線程共享全局變量
    線程時(shí)進(jìn)程的執(zhí)行單元，進(jìn)程時(shí)系統(tǒng)分配資源的最小執(zhí)行單位，所以在同一個(gè)進(jìn)程中的多線程是共享資源的
'''
# g_num = 100
# def work1():
#     global  g_num
#     for i in range(3):
#         g_num+=1
#     print('in work1 g_num is : %d' % g_num)
#
# def work2():
#     global g_num
#     print('in work2 g_num is : %d' % g_num)
#
# if __name__ == '__main__':
#     t1 = threading.Thread(target=work1)
#     t1.start()
#     time.sleep(1)
#     t2=threading.Thread(target=work2)
#     t2.start()
 
 
'''
        由于線程之間是進(jìn)行隨機(jī)調(diào)度，并且每個(gè)線程可能只執(zhí)行n條執(zhí)行之后，當(dāng)多個(gè)線程同時(shí)修改同一條數(shù)據(jù)時(shí)可能會(huì)出現(xiàn)臟數(shù)據(jù)，
    所以出現(xiàn)了線程鎖，即同一時(shí)刻允許一個(gè)線程執(zhí)行操作。線程鎖用于鎖定資源，可以定義多個(gè)鎖，像下面的代碼，當(dāng)需要獨(dú)占
    某一個(gè)資源時(shí)，任何一個(gè)鎖都可以鎖定這個(gè)資源，就好比你用不同的鎖都可以把這個(gè)相同的門鎖住一樣。
        由于線程之間是進(jìn)行隨機(jī)調(diào)度的，如果有多個(gè)線程同時(shí)操作一個(gè)對(duì)象，如果沒(méi)有很好地保護(hù)該對(duì)象，會(huì)造成程序結(jié)果的不可預(yù)期，
    我們因此也稱為“線程不安全”。
        為了防止上面情況的發(fā)生，就出現(xiàn)了互斥鎖（Lock）
'''
# def work():
#     global n
#     lock.acquire()
#     temp = n
#     time.sleep(0.1)
#     n = temp-1
#     lock.release()
#
#
# if __name__ == '__main__':
#     lock = Lock()
#     n = 100
#     l = []
#     for i in range(100):
#         p = Thread(target=work)
#         l.append(p)
#         p.start()
#     for p in l:
#         p.join()
 
 
'''
    遞歸鎖：RLcok類的用法和Lock類一模一樣，但它支持嵌套，在多個(gè)鎖沒(méi)有釋放的時(shí)候一般會(huì)使用RLock類
'''
# def func(lock):
#     global gl_num
#     lock.acquire()
#     gl_num += 1
#     time.sleep(1)
#     print(gl_num)
#     lock.release()
#
#
# if __name__ == '__main__':
#     gl_num = 0
#     lock = threading.RLock()
#     for i in range(10):
#         t = threading.Thread(target=func,args=(lock,))
#         t.start()
 
 
'''
    信號(hào)量（BoundedSemaphore類）
    互斥鎖同時(shí)只允許一個(gè)線程更改數(shù)據(jù)，而Semaphore是同時(shí)允許一定數(shù)量的線程更改數(shù)據(jù)，比如廁所有3個(gè)坑，
    那最多只允許3個(gè)人上廁所，后面的人只能等里面有人出來(lái)了才能再進(jìn)去
'''
# def run(n,semaphore):
#     semaphore.acquire()   #加鎖
#     time.sleep(3)
#     print('run the thread:%s\n' % n)
#     semaphore.release()    #釋放
#
#
# if __name__== '__main__':
#     num=0
#     semaphore = threading.BoundedSemaphore(5)   #最多允許5個(gè)線程同時(shí)運(yùn)行
#     for i in range(22):
#         t = threading.Thread(target=run,args=('t-%s' % i,semaphore))
#         t.start()
#     while threading.active_count() !=1:
#         pass
#     else:
#         print('----------all threads done-----------')
 
'''
    python線程的事件用于主線程控制其他線程的執(zhí)行，事件是一個(gè)簡(jiǎn)單的線程同步對(duì)象，其主要提供以下的幾個(gè)方法：
        clear將flag設(shè)置為 False
        set將flag設(shè)置為 True
        is_set判斷是否設(shè)置了flag
        wait會(huì)一直監(jiān)聽(tīng)flag，如果沒(méi)有檢測(cè)到flag就一直處于阻塞狀態(tài)
    事件處理的機(jī)制：全局定義了一個(gè)Flag，當(dāng)Flag的值為False，那么event.wait()就會(huì)阻塞，當(dāng)flag值為True，
    那么event.wait()便不再阻塞
'''
event = threading.Event()
def lighter():
    count = 0
    event.set()         #初始者為綠燈
    while True:
        if 5 < count <=10:
            event.clear()  #紅燈，清除標(biāo)志位
            print("\33[41;lmred light is on...\033[0m]")
        elif count > 10:
            event.set()    #綠燈，設(shè)置標(biāo)志位
            count = 0
        else:
            print('\33[42;lmgreen light is on...\033[0m')
 
        time.sleep(1)
        count += 1
 
 
def car(name):
    while True:
        if event.is_set():     #判斷是否設(shè)置了標(biāo)志位
            print('[%s] running.....'%name)
            time.sleep(1)
        else:
            print('[%s] sees red light,waiting...'%name)
            event.wait()
            print('[%s] green light is on,start going...'%name)
 
 
# startTime = time.time()
light = threading.Thread(target=lighter,)
light.start()
 
car = threading.Thread(target=car,args=('MINT',))
car.start()
endTime = time.time()
# print('用時(shí)：',endTime-startTime)
 
'''
                           GIL  全局解釋器
        在非python環(huán)境中，單核情況下，同時(shí)只能有一個(gè)任務(wù)執(zhí)行。多核時(shí)可以支持多個(gè)線程同時(shí)執(zhí)行。但是在python中，無(wú)論有多少個(gè)核
        同時(shí)只能執(zhí)行一個(gè)線程。究其原因，這就是由于GIL的存在導(dǎo)致的。
        GIL的全程是全局解釋器，來(lái)源是python設(shè)計(jì)之初的考慮，為了數(shù)據(jù)安全所做的決定。某個(gè)線程想要執(zhí)行，必須先拿到GIL，我們可以
        把GIL看做是“通行證”，并且在一個(gè)python進(jìn)程之中，GIL只有一個(gè)。拿不到線程的通行證，并且在一個(gè)python進(jìn)程中，GIL只有一個(gè)，
        拿不到通行證的線程，就不允許進(jìn)入CPU執(zhí)行。GIL只在cpython中才有，因?yàn)閏python調(diào)用的是c語(yǔ)言的原生線程，所以他不能直接操
        作cpu，而只能利用GIL保證同一時(shí)間只能有一個(gè)線程拿到數(shù)據(jù)。而在pypy和jpython中是沒(méi)有GIL的
        python在使用多線程的時(shí)候，調(diào)用的是c語(yǔ)言的原生過(guò)程。
'''
'''
                            python針對(duì)不同類型的代碼執(zhí)行效率也是不同的
        1、CPU密集型代碼（各種循環(huán)處理、計(jì)算等），在這種情況下，由于計(jì)算工作多，ticks技術(shù)很快就會(huì)達(dá)到閥值，然后出發(fā)GIL的
        釋放與再競(jìng)爭(zhēng)（多個(gè)線程來(lái)回切換當(dāng)然是需要消耗資源的），所以python下的多線程對(duì)CPU密集型代碼并不友好。
        2、IO密集型代碼（文件處理、網(wǎng)絡(luò)爬蟲(chóng)等設(shè)計(jì)文件讀寫操作），多線程能夠有效提升效率（單線程下有IO操作會(huì)進(jìn)行IO等待，
        造成不必要的時(shí)間浪費(fèi)，而開(kāi)啟多線程能在線程A等待時(shí)，自動(dòng)切換到線程B，可以不浪費(fèi)CPU的資源，從而能提升程序的執(zhí)行
        效率）。所以python的多線程對(duì)IO密集型代碼比較友好。
'''
'''
    主要要看任務(wù)的類型，我們把任務(wù)分為I/O密集型和計(jì)算密集型，而多線程在切換中又分為I/O切換和時(shí)間切換。如果任務(wù)屬于是I/O密集型，
    若不采用多線程，我們?cè)谶M(jìn)行I/O操作時(shí)，勢(shì)必要等待前面一個(gè)I/O任務(wù)完成后面的I/O任務(wù)才能進(jìn)行，在這個(gè)等待的過(guò)程中，CPU處于等待
    狀態(tài)，這時(shí)如果采用多線程的話，剛好可以切換到進(jìn)行另一個(gè)I/O任務(wù)。這樣就剛好可以充分利用CPU避免CPU處于閑置狀態(tài)，提高效率。但是
    如果多線程任務(wù)都是計(jì)算型，CPU會(huì)一直在進(jìn)行工作，直到一定的時(shí)間后采取多線程時(shí)間切換的方式進(jìn)行切換線程，此時(shí)CPU一直處于工作狀態(tài)，
    此種情況下并不能提高性能，相反在切換多線程任務(wù)時(shí)，可能還會(huì)造成時(shí)間和資源的浪費(fèi)，導(dǎo)致效能下降。這就是造成上面兩種多線程結(jié)果不能的解釋。
結(jié)論:I/O密集型任務(wù)，建議采取多線程，還可以采用多進(jìn)程+協(xié)程的方式(例如:爬蟲(chóng)多采用多線程處理爬取的數(shù)據(jù))；對(duì)于計(jì)算密集型任務(wù)，python此時(shí)就不適用了。
'''