import threading
# 從數(shù)據(jù)庫提取數(shù)據(jù)的類
class Scheduler():
    def __init__(self):
        self._lock = threading.RLock()
        self.start = 0
        # 每次取10000條數(shù)據(jù)
        self.step = 10000

    def getdata(self):
        # 上鎖，以免多線程同時對數(shù)據(jù)庫進(jìn)行訪問，取出重復(fù)數(shù)據(jù)
        self._lock.acquire()
        # 進(jìn)行取數(shù)據(jù)操作
        data = 'select * from table' \
               'where id between self.start and self.start + self.step'
        # 取完數(shù)據(jù)后，指針后移
        self.start += self.step
        self._lock.release()
        return data

# 處理數(shù)據(jù)的過程寫在這里
def processdata():
    # 從該實(shí)例中提取數(shù)據(jù)
    data = scheduler.getdata()
    while data:
        # 進(jìn)行處理數(shù)據(jù)的具體操作:
        # 去重、補(bǔ)缺、運(yùn)算...只要還有數(shù)據(jù)，本線程就繼續(xù)取新數(shù)據(jù)
        # 然后再獲取數(shù)據(jù)，進(jìn)行循環(huán)
        data = scheduler.getdata()

# 創(chuàng)建多線程，threads_num為創(chuàng)建的線程數(shù)
def threads_scheduler(threads_num):
    threads = []
    for i in range(threads_num):
        # 創(chuàng)建線程
        td = threading.Thread(target=processdata, name='th'+str(i+1))
        threads.append(td)
    for t in threads:
        # 啟動線程
        t.start()
        for t in threads:
            # 子線程守護(hù)
            t.join()
            print('數(shù)據(jù)已全部處理成功')

if __name__=='__main__':
    # 實(shí)例化一個調(diào)度器，初始化參數(shù)
    scheduler = Scheduler()
    # 創(chuàng)建線程，開始處理數(shù)據(jù)
    threads_scheduler(4)

from time import sleep
import threading

def music(music_name):
    for i in range(2):
        print('正在聽{}'.format(music_name))
        sleep(1)
        print('music over')

def game(game_name):
    for i in range(2):
        print('正在玩{}'.format(game_name))
        sleep(3)
        print('game over')

threads = []
t1 = threading.Thread(target=music,args=('稻香',))
threads.append(t1)
t2 = threading.Thread(target=game,args=('飛車',))
threads.append(t2)

if __name__ == '__main__':
    for t in threads:
        # t.setDaemon(True)
        t.start()
        
    for t in threads:
        t.join()
    print('主線程運(yùn)行結(jié)束')

from time import sleep
# fun為定義的待運(yùn)行函數(shù)
with ThreadPoolExecutor(max_workers=5) as executor:
    ans = executor.map(fun, [遍歷值])
    for res in ans:
        print(res)

with ThreadPoolExecutor(max_workers=5) as executor:
    list = [遍歷值]
    ans = [executor.submit(fun, i) for i in list]
    for res in as_completed(ans):
        print(res.result())

class Account:
    def __init__(self, card_id, balance):
        # 封裝賬戶ID、賬戶余額的兩個變量
        self.card_id= card_id
        self.balance = balance
        
def withdraw(account, money):
    # 進(jìn)行加鎖
    lock.acquire()
    # 賬戶余額大于取錢數(shù)目
    if account.balance >= money:
        # 吐出鈔票
        print(threading.current_thread().name + "取錢成功！吐出鈔票:" + str(money),end=' ')
        # 修改余額
        account.balance -= money
        print("\t余額為: " + str(account.balance))
    else:
        print(threading.current_thread().name + "取錢失敗！余額不足")
    # 進(jìn)行解鎖
    lock.release()
# 創(chuàng)建一個賬戶，銀行卡id為8888，存款1000元
acct = Account("8888" , 1000)

# 模擬兩個對同一個賬戶取錢
# 在主線程中創(chuàng)建一把鎖
lock = threading.Lock()
threading.Thread(name='窗口A', target=withdraw , args=(acct , 800)).start()
threading.Thread(name='窗口B', target=withdraw , args=(acct , 800)).start()

import threading

def main():
    lock.acquire()
    print('第一道鎖')
    lock.acquire()
    print('第二道鎖')
    lock.release()
    lock.release()
    
if __name__ == '__main__':
    lock = threading.Lock()
    main()

import threading

def main():
    lock.release()
    print("在子線程解鎖后打印")
if __name__ == '__main__':
    lock = threading.Lock()
    lock.acquire()
    t = threading.Thread(target=main)
    t.start()

import threading
import time

def fun_1():
    print('開始')
    time.sleep(1)
    lock.acquire()
    print("第一道鎖")
    fun_2()
    lock.release()
    
def fun_2():
    lock.acquire()
    print("第二道鎖")
    lock.release()
    
if __name__ == '__main__':
    lock = threading.RLock()
    t1 = threading.Thread(target=fun_1)
    t2 = threading.Thread(target=fun_1)
    t1.start()
    t2.start()