# -*- coding:utf-8 -*-
# 線程使用的方式一
import threading
import time
# 需要多線程運行的函數(shù)
def fun(args):
    print("我是線程%s" % args)
    time.sleep(2)
    print("線程%s運行結(jié)束" % args)
# 創(chuàng)建線程
t1 = threading.Thread(target=fun, args=(1,))
t2 = threading.Thread(target=fun, args=(2,))
start_time = time.time()
t1.start()
t2.start()
end_time = time.time()
print("兩個線程一共的運行時間為：", end_time-start_time)
print("主線程結(jié)束")
"""
運行結(jié)果：
我是線程1
我是線程2兩個線程一共的運行時間為： 0.0010077953338623047
主線程結(jié)束
線程1運行結(jié)束
線程2運行結(jié)束
"""

# 繼承式調(diào)用
import threading
import time
class MyThreading(threading.Thread):
    def __init__(self, name):
        super(MyThreading, self).__init__()
        self.name = name
    # 線程要運行的代碼
    def run(self):
        print("我是線程%s" % self.name)
        time.sleep(2)
        print("線程%s運行結(jié)束" % self.name)
t1 = MyThreading(1)
t2 = MyThreading(2)
start_time = time.time()
t1.start()
t2.start()
end_time = time.time()
print("兩個線程一共的運行時間為：", end_time-start_time)
print("主線程結(jié)束")
"""
運行結(jié)果：
我是線程1
我是線程2
兩個線程一共的運行時間為： 0.0010724067687988281
主線程結(jié)束
線程2運行結(jié)束
線程1運行結(jié)束
"""

# 守護線程
import threading
import time
class MyThreading(threading.Thread):
    def __init__(self, name):
        super(MyThreading, self).__init__()
        self.name = name
    # 線程要運行的代碼
    def run(self):
        print("我是線程%s" % self.name)
        time.sleep(2)
        print("線程%s運行結(jié)束" % self.name)
t1 = MyThreading(1)
t2 = MyThreading(2)
start_time = time.time()
t1.setDaemon(True)
t1.start()
t2.setDaemon(True)
t2.start()
end_time = time.time()
print("兩個線程一共的運行時間為：", end_time-start_time)
print("主線程結(jié)束")

# join:線程同步
import threading
import time
class MyThreading(threading.Thread):
    def __init__(self, name):
        super(MyThreading, self).__init__()
        self.name = name
    # 線程要運行的代碼
    def run(self):
        print("我是線程%s" % self.name)
        time.sleep(3)
        print("線程%s運行結(jié)束" % self.name)
threading_list = []
start_time = time.time()
for x in range(50):
    t = MyThreading(x)
    t.start()
    threading_list.append(t)
for x in threading_list:
    x.join()    # 為線程開啟同步
end_time = time.time()
print("50個線程一共的運行時間為：", end_time-start_time)
print("主線程結(jié)束")

# -*- coding:utf8  -*-
import threading
import time
num = 100
threading_list = []
def fun():
    global num
    print("get num:", num)
    num += 1
    time.sleep(1)
for x in range(200):
    t = threading.Thread(target=fun)
    t.start()
    threading_list.append(t)
for x in threading_list:
    x.join()
print("nun:", num)

import random
import threading
import time
num = 100
threading_list = []
def fun():
    global num
    time.sleep(random.random())
    lock.acquire() # 加鎖
    print("get num:", num, threading.current_thread())
    num += 1
    lock.release()  # 釋放鎖
# 實例化鎖對象
lock = threading.Lock()
for x in range(200):
    t = threading.Thread(target=fun)
    t.start()
    threading_list.append(t)
for x in threading_list:
    x.join()
print("num:", num)

import threading, time
def run1():
    lock.acquire()
    print("grab the first part data")
    global num
    num += 1
    lock.release()
    return num
def run2():
    lock.acquire()
    print("grab the second part data")
    global num2
    num2 += 1
    lock.release()
    return num2
def run3():
    lock.acquire()
    res = run1()
    print('--------between run1 and run2-----')
    res2 = run2()
    lock.release()
    print(res, res2)
if __name__ == '__main__':
    num, num2 = 0, 0
    lock = threading.RLock()
    for i in range(3):
        t = threading.Thread(target=run3)
        t.start()
while threading.active_count() != 1:
    print(threading.active_count())
else:
    print('----all threads done---')
    print(num, num2)

import threading
data_list = []
lock_object = threading.RLock()
def task():
    print("開始")
    for i in range(1000000):
        data_list.append(i)
    print(len(data_list))
for i in range(2):
    t = threading.Thread(target=task)
    t.start()

# -*- coding:GBK -*-
import threading
import time

sum_1 = 0
def run(i):
    global sum_1
    time.sleep(1)
    # lock.acquire()
    semaphore.acquire()
    sum_1 += 1
    print("線程%s來了,并修改了sum_1的值為：%s" % (i, sum_1))
    semaphore.release()
    # lock.release()

# lock = threading.Lock()
semaphore = threading.BoundedSemaphore(5)

for x in range(10):
    t = threading.Thread(target=run, args=(x,))
    t.start()

while threading.active_count() != 1:
    pass

print("程序結(jié)束")

# -*- coding:utf-8 -*-
import threading
import time
def light():
    count = 1
    event.set()  # 設(shè)置標(biāo)志位 True
    while True:
        if count <= 10:
            print("現(xiàn)在是綠燈")
            time.sleep(1)
        elif count <= 15:
            print("現(xiàn)在是紅燈")
            event.clear()   # 清空標(biāo)志位(將標(biāo)志位改為false)
            time.sleep(1)
        else:
            count = 0
            event.set()
        count += 1
def car(name):
    while True:
        if event.is_set():
            print("----------%s在起飛-------------" % name)
            time.sleep(1)
        else:
            print("---------%s在等紅燈---------------" % name)
            event.wait()   # 等待標(biāo)志位被設(shè)置位True程序才繼續(xù)往下運行
event = threading.Event()
light_1 = threading.Thread(target=light)
light_1.start()
for x in range(5):
    car_1 = threading.Thread(target=car, args=("馬自達(dá)"+str(x),))
    car_1.start()

queue.Queue(maxsize=0)
#隊列：先進(jìn)先出  maxsize:設(shè)置隊列的大小
queue.LifoQueue(maxsize=0)
##last in fisrt out  maxsize:設(shè)置隊列的大小
queue.PriorityQueue(maxsize=0)
#存儲數(shù)據(jù)時可設(shè)置優(yōu)先級的隊列,按優(yōu)先級順序（最低的先）  maxsize:設(shè)置隊列的大小  

import queue
# 實例化隊列對象
q = queue.Queue(3)
print(q.qsize())    # 獲取隊列內(nèi)數(shù)據(jù)的長度
print(q.empty())    # 如果隊列是空的，返回True，否則返回False（不可靠！）
print(q.full())     # 如果隊列已滿，返回True，否則返回False（不可靠?。?
"""
Queue.put(item, block=True, timeout=None)
可以簡寫：Queue.put(item, True, 5)
將項目放入隊列。
如果可選的args block為true(默認(rèn)值)，并且timeout為None（默認(rèn)值），必要時進(jìn)行阻塞，直到有空閑的槽。
如果timeout是一個正數(shù)，它最多阻斷timeout秒，如果在這段時間內(nèi)沒有空閑槽，則引發(fā)Full異常。
否則（block為false），如果有空閑的槽立即可用，就在隊列上放一個項目，否則就引發(fā)Full異常（在這種情況下忽略超時）。
"""
q.put(1)            # 數(shù)據(jù)“1”進(jìn)入隊列
q.put("nihao")      # 數(shù)據(jù)"nihao"進(jìn)入隊列
q.put("456ni", block=True, timeout=5)
'''
將一個項目放入隊列中，不進(jìn)行阻斷。
只有在有空閑位置的情況下才排隊。
否則會引發(fā)Full異常。
'''
# q.put_nowait(123)

'''
Queue.get(block=True, timeout=None)
可以簡寫：Queue.get(True, 3)
從隊列中刪除并返回一個項目。
如果可選的args'block'為True(默認(rèn))，'timeout'為無（默認(rèn)）。
    就會在必要時阻塞，直到有一個項目可用。
    如果'timeout'是非負(fù)數(shù)，它最多阻斷'timeout'秒，如果在這段時間內(nèi)沒有項目可用，則引發(fā)Empty異常。
否則（'block'為False），如果有一個項目立即可用，則返回一個項目。
    否則引發(fā)Empty異常（'timeout'被忽略了在這種情況下）。
'''
print(q.get())
print(q.get())
print(q.get())
print(q.get(block=True, timeout=2))
'''
從隊列中移除并返回一個項目，而不阻塞。
只有當(dāng)一個項目立即可用時，才會得到一個項目。
否則引發(fā)Empty異常。
'''
# print(q.get_nowait())

# 生產(chǎn)者/消費者
import threading
import queue
import time
# 生產(chǎn)者
def producer(name):
    count = 1
    while True:
        p.put("{}骨頭{}".format(name, count))
        print("骨頭{}被{}生產(chǎn)".format(count, name).center(60, "*"))
        count += 1
        time.sleep(0.1)
# 消費者
def consumer(name):
    while True:
        print("{}被{}吃掉了".format(p.get(), name))
# 實例化隊列對象
p = queue.Queue(10)
# 創(chuàng)建生產(chǎn)者線程
producer_threading1 = threading.Thread(target=producer, args=("飛某人",))
producer_threading2 = threading.Thread(target=producer, args=("Alex",))
# 創(chuàng)建消費者線程
consumer_threading1 = threading.Thread(target=consumer, args=("張三",))
consumer_threading2 = threading.Thread(target=consumer, args=("李四",))
producer_threading1.start()
producer_threading2.start()
consumer_threading1.start()
consumer_threading2.start()

import threading
def task(video_url):
    pass
url_list = ["www.xxxx-{}.com".format(i) for i in range(30000)]
for url in url_list:
    t = threading.Thread(target=task, args=(url,))
    t.start()
# 這種每次都創(chuàng)建一個線程去操作，創(chuàng)建任務(wù)的太多，線程就會特別多，可能效率反倒降低了。

import time
from concurrent.futures import ThreadPoolExecutor  # 并行期貨，線程池執(zhí)行者
"""
pool = ThreadPoolExecutor(100)
pool.submit(函數(shù)名,參數(shù)1，參數(shù)2，參數(shù)...)
"""
def task(video_url, num):
    print("開始執(zhí)行任務(wù)", video_url, num)     # 開始執(zhí)行任務(wù) www.xxxx-299.com 3
    time.sleep(1)
# 創(chuàng)建線程池，最多維護10個線程
threadpool = ThreadPoolExecutor(10)
# 生成300網(wǎng)址，并放入列表
url_list = ["www.xxxx-{}.com".format(i) for i in range(300)]
for url in url_list:
    """
    在線程池中提交一個任務(wù)，線程池如果有空閑線程，則分配一個線程去執(zhí)行，執(zhí)行完畢后在將線程交還給線程池，
    如果沒有空閑線程，則等待。注意在等待時，與主線程無關(guān)，主線程依然在繼續(xù)執(zhí)行。
    """
    threadpool.submit(task, url, 3)
print("等待線程池中的任務(wù)執(zhí)行完畢中······")
threadpool.shutdown(True)   # 等待線程池中的任務(wù)執(zhí)行完畢后，在繼續(xù)執(zhí)行
print("END")

"""線程池的回調(diào)"""
import time
import random
from concurrent.futures import ThreadPoolExecutor
def task(video_url):
    print("開始執(zhí)行任務(wù)", video_url)
    time.sleep(1)
    return random.randint(0, 10)    # 將結(jié)果封裝成一個Futuer對象，返回給線程池
def done(response):     # response就是futuer對象，也就是task的返回值分裝的一個Futuer對象
    print("任務(wù)執(zhí)行完后，回調(diào)的函數(shù)", response.result())    # 即Futuer.result()：取出task的返回值
# 創(chuàng)建線程池
threadpool = ThreadPoolExecutor(10)
url_list = ["www.xxxx-{}.com".format(i) for i in range(5)]
for url in url_list:
    futuer = threadpool.submit(task, url)    # futuer是由task返回的一個Future對象，里面有記錄task的返回值
    futuer.add_done_callback(done)           # 回調(diào)done函數(shù)，執(zhí)行者依然是子線程
# 優(yōu)點：可以做分工，例如：task專門下載，done專門將下載的數(shù)據(jù)寫入本地文件。