9.17(day38)線程內容，開啓線程的兩種方式，子線程共享資源，線程的join方法，線程的其餘用法，守護線程

昨日回顧

join會把全部代碼變爲串行
因此須要進程鎖：
到如lock模塊
def xxx(lock):
代碼
lock.acquire()
處理數據
lock.release()

進程通信：ipc機制
Queue:隊列模式 管道加鎖
管道：基於共享內存
put.get(),條件不知足阻塞

若是block=False，不知足直接報錯

生產者消費者模型
生產者只須要不停的生產,達到了本身的最大效率,
消費者也只須要不聽的消費,也達到了本身的最大效率.
生產者消費者模型,大大提升了生產者的生產效率,也大大提升了消費者的消費效率.

joinablequeue:
計數器：put+1 task_done-1
join() 計數器不爲0是阻塞，

線程內容

在操做系統中，每一個進程有一個地址空間，並且默認就有一個控制線程，cpu真正的執行單位是線程
在工廠中，每一個車間都有房子，並且每一個房間默認就有一條流水線，

操做系統：工廠
進程：車間
流程：流水線
cpu:電源

線程：cpu最小的執行單位
進程：資源集合，資源單位
線程運行=運行代碼
進程運行=各類資源+線程

右鍵運行：
申請內存空間，先把解釋器丟進去並把代碼丟進去(進程作的)，運行代碼(線程)

進程線程的區別：
線程：單指代碼的執行過程
進程：資源的申請與銷燬的過程

進程內存空間彼此隔離
同一個進程下的線程共享資源

進程和線程的建立速度：
進程須要申請資源開闢空間 慢
只是告訴操做系統一個執行方法 快

線程兩種開啓方式

同進程，能夠不寫main語句

第一種
from threading import Thread
import time

def task():
    print('start')
    time.sleep(2)
    print('end')

if __name__ == '__main__':   # 可寫可不寫
    t = Thread(target=task)
    t.start()   # 告訴操做系統開啓線程
    print('主線程')

第二種
from threading import Thread
import time
# 進程等待全部子進程結束纔會結束
class Myt(Thread):
    def run(self):
        print('start')
        time.sleep(2)
        print('end')

t = Myt()
t.start()
print('主線程')

子進程子線程的開啓速度
from threading import Thread
from multiprocessing import Process
import time

def task(name):
    print(f'{name}is run')
    time.sleep(2)
    print(f'{name}is end')

if __name__ == '__main__':
    t = Thread(target=task,args=('子線程',))
    p = Process(target=task,args=('子進程',))
    t.start()
    print('主')

子線程共享資源測試

from threading import Thread
import time
x = 100
def task():
    global x
    x = 50
if __name__ == '__main__':

    t = Thread(target=task)
    t.start()
    time.sleep(2)
    print(x)

線程的join方法

一個join
from threading import Thread
import time
def task():
    print('start')
    time.sleep(2)
    print('end')

t = Thread(target=task)
t.start()
t.join()   # 等待子線程運行結束
print('主線程')

多個join
from threading import Thread
import time
def task(name,n):
    print(f'{name}start')
    time.sleep(n)
    print(f'{name}end')

t1 = Thread(target=task,args=('線程1',1))
t2 = Thread(target=task,args=('線程2',2))
t3 = Thread(target=task,args=('線程3',3))
start = time.time()
t1.start()
t2.start()
t3.start()
t1.join()   # 等待子線程運行結束
t2.join()
t3.join()
end = time.time()
print(end-start)
print('主線程')

瞭解進程的join
from multiprocessing import Process
from threading import Thread
import time
def task():
    print('進程開啓')
    time.sleep(2)
    print('進程結束')

def task2():
    print('進程開啓')
    time.sleep(2)
    print('進程結束')

if __name__ =='__main__':
    p = Process(target=task)
    t = Thread(target=task2)
    t.start()
    p.start()
    print('子進程join開始')
    p.join()   # 主進程的主線程等待子進程運行結束
    print('主')

線程的其餘用法

from threading import Thread,currentThread,enumerate,activeCount
import time
def task():
    print('start')
    time.sleep(2)
    print('end')
    print(enumerate())

if __name__ == '__main__':
    t = Thread(target=task)
    t.start()
    print(t.is_alive())    # 是否存活
    print(t.getName())   # 獲取名字
    t.setName('qxq')   # 設置名字
    print(t.getName())
    print(currentThread())   # 當前線程變量
    print(enumerate())   # 三個活躍的線程(不包括啓動前，終止後的)
    print(activeCount())   # 活躍進程數量
    print(len(enumerate()))

守護線程

守護的是線程的運行週期
from threading import Thread
import time

def task():
    print('守護線程開始')
    time.sleep(2)
    print('守護線程結束')

def task2():
    print('子線程開始')
    time.sleep(5)
    print('子線程結束')

if __name__ == '__main__':
    t1 = Thread(target=task)
    t2 = Thread(target=task2)
    t1.daemon = True
    t1.start()
    t2.start()
    print('主')