線程之線程的一些其餘方法，線程的事件，線程隊列，線程池，GIL鎖，協程的認識，Greenlet,Gevent

#協程greenlet
from greenlet import greenlet

def eat(name):
    print('%s eat 1'%name)
    g2.switch('taibai')#第一次調用必須傳值
    print('%s eat 2'%name)
    g2.switch()

def play(name):
    print('%s play 1'%name)
    g1.switch()
    print('%s play 2'%name)

g1=greenlet(eat)
g2=greenlet(play)

g1.switch('taibai')

# 線程的其餘方法

from threading import Thread
import threading
import time
from multiprocessing import Process
import os


def work():
    import time
    time.sleep(1)
    # print('子線程',threading.get_ident()) #2608
    print(threading.current_thread().getName())  # Thread-1


if __name__ == '__main__':
    # 在主進程下開啓線程
    t = Thread(target=work)
    t.start()

    # print(threading.current_thread())#主線程對象 #<_MainThread(MainThread, started 1376)>
    # print(threading.current_thread().getName()) #主線程名稱 #MainThread
    # print(threading.current_thread().ident) #主線程ID #1376
    # print(threading.get_ident()) #主線程ID #1376

    time.sleep(3)
    print(
        threading.enumerate())  # 連同主線程在內有兩個運行的線程,[<_MainThread(MainThread, started 13396)>, <Thread(Thread-1, started 572)>]
    print(threading.active_count())  # 2
    print('主線程/主進程')



# 隊列
import queue
#隊列先進先出
q2=queue.Queue()
q2.put('frist')
q2.put('second')
q2.put('third')
print(q2.get())
print(q2.get())
print(q2.get())

#相似於棧的隊列
q1=queue.LifoQueue()
q1.put(1)
q1.put(2)
q1.put(3)
print(q1.get())
print(q1.get())
print(q1.get())
# print(q1.get())#阻塞

#優先級隊列
import queue
q=queue.PriorityQueue()#建立優先級隊列對象
q.put((-1,'666'))
q.put((0,'999'))
q.put((3,'hahaha'))
q.put((9,'123'))
print(q.get())
print(q.get())
print(q.get())
print(q.get())

#線程池的方法
from concurrent.futures import ThreadPoolExecutor,ProcessPoolExecutor
def func(i):
    print(i)
    time.sleep(1)
    return i**2
t_pool=ThreadPoolExecutor(max_workers=4)#實例化個線程池，設置最大線程數
ret=t_pool.map(func,range(10))#map自帶join,返回生成器
print(ret,[i for i in ret])


#多線程與多進程在純計算或者io密集型的兩種場景運行時間的比較
from multiprocessing import Process
from threading import Thread

def func():
    num=0
    # time.sleep(1)
    for i in range(100000000):
        num += i

if __name__ == '__main__':
    p_s_t = time.time()
    p_list = []
    for i in range(10):
        p = Process(target=func, )
        p_list.append(p)
        p.start()
    [pp.join() for pp in p_list]
    p_e_t = time.time()
    p_dif_t = p_e_t - p_s_t

    t_s_t=time.time()
    t_list = []
    for i in range(10):
        t=Thread(target=func,)
        t_list.append(t)
        t.start()
    [tt.join() for tt in t_list]
    t_e_t=time.time()
    t_dif_t=t_e_t-t_s_t

    print("多進程：", p_dif_t)
    print("多線程：",t_dif_t)

#純計算的程序切換反而更慢
import time
def consumer():
    '''任務1:接收數據,處理數據'''
    while True:
        x=yield
        # time.sleep(1) #發現什麼？只是進行了切換，可是並無節省I/O時間
        print('處理了數據：',x)
def producer():
    '''任務2:生產數據'''
    g=consumer()
    # print('asdfasfasdf')
    next(g)  #找到了consumer函數的yield位置
    for i in range(3):
    # for i in range(10000000):
        g.send(i)  #給yield傳值，而後再循環給下一個yield傳值，而且多了切換的程序，比直接串行執行還多了一些步驟，致使執行效率反而更低了。
        print('發送了數據：',i)
start=time.time()
#基於yield保存狀態,實現兩個任務直接來回切換,即併發的效果
#PS:若是每一個任務中都加上打印,那麼明顯地看到兩個任務的打印是你一次我一次,即併發執行的.
producer() #我在當前線程中只執行了這個函數，可是經過這個函數裏面的send切換了另一個任務
stop=time.time()

# 串行執行的方式
res=producer()
consumer(res)
stop=time.time()

print(stop-start)