import threading
import time

def run(name, s): # 線程要執(zhí)行的任務(wù)
 time.sleep(s) # 停兩秒
 print('I am %s' % name)

# 實(shí)例化線程類, 并傳入函數(shù)及其參數(shù), 
t1 = threading.Thread(target=run, name='one', args=('One', 5))
t2 = threading.Thread(target=run, name='two', args=('Two', 2))

# 開始執(zhí)行, 這兩個(gè)線程會(huì)同步執(zhí)行
t1.start()
t2.start()
print(t1.getName())		# 獲取線程名
print(t2.getName())

# Result:
one
two
I am Two	# 運(yùn)行2s后
I am One	# 運(yùn)行5s后

class MyThread(threading.Thread): # 繼承threading中的Thread類
 # 線程所需的參數(shù)
 def __init__(self, name, second):
 super().__init__()
 self.name = name
 self.second = second

 # 重寫run方法,表示線程所執(zhí)行的任務(wù),必須有
 def run(self):
 time.sleep(self.second)
 print('I am %s' % self.name)
# 創(chuàng)建線程實(shí)例
t1 = MyThread('One', 5)
t2 = MyThread('Two', 2)
# 啟動(dòng)線程,實(shí)際上是調(diào)用了類中的run方法
t1.start()
t2.start()
t1.join()
print(t1.getName())
print(t2.getName())

# Result:
I am Two	# 運(yùn)行后2s
I am One	# 運(yùn)行后5s
One
Two

# 開始執(zhí)行, 這兩個(gè)線程會(huì)同步執(zhí)行
t1.start()
t2.start()
t1.join()	# 等待t1線程執(zhí)行完畢,再繼續(xù)執(zhí)行剩余的代碼
print(t1.getName())
print(t2.getName())

# Result:	
I am Two
I am One
one
two

def run(name, s): # 線程要執(zhí)行的函數(shù)
 time.sleep(s) # 停兩秒
 print('I am %s' % name)

# 實(shí)例化線程類, 并傳入函數(shù)及其參數(shù)
t1 = threading.Thread(target=run, name='one', args=('One', 5))
t2 = threading.Thread(target=run, name='two', args=('Two', 2))
# 給t1設(shè)置守護(hù)模式, 使其隨著主線程的結(jié)束而結(jié)束
t1.setDaemon(True)
# 開始執(zhí)行, 這兩個(gè)線程會(huì)同步執(zhí)行
t1.start()
t2.start()	# 主線程會(huì)等待未設(shè)置守護(hù)模式的線程t2執(zhí)行完成

# Result:
I am Two	# 運(yùn)行后2s

a = 0
def incr(n):
 global a
 for i in range(n):
 a += 1
# 這兩個(gè)方法同時(shí)聲明了變量a,并對(duì)其進(jìn)行修改
def decr(n):
 global a
 for i in range(n):
 a -= 1

t_incr = threading.Thread(target=incr, args=(1000000,))
t_decr = threading.Thread(target=decr, args=(1000000,))
t_incr.start()
t_decr.start()
t_incr.join()
t_decr.join()
print(a)
# 期望結(jié)果應(yīng)該是0, 但是因?yàn)檫@里沒(méi)有設(shè)置互斥鎖, 所以兩個(gè)方法是同時(shí)對(duì)同一個(gè)變量進(jìn)行修改, 得到的的結(jié)果值是隨機(jī)的

a = 0
lock = threading.Lock()	# 實(shí)例化互斥鎖對(duì)象, 方便之后的調(diào)用

def incr(n):
 global a
 for i in range(n):
 lock.acquire()	# 上鎖的方法
 a += 1
 lock.release()	# 解鎖的方法
# 要注意的是上鎖的位置是, 出現(xiàn)修改操作的代碼
def decr(n):
 global a
 for i in range(n):
 with lock:	# 也可以直接使用with, 自動(dòng)解鎖
  a -= 1

t_incr = threading.Thread(target=incr, args=(1000000,))
t_decr = threading.Thread(target=decr, args=(1000000,))
t_incr.start()
t_decr.start()
t_incr.join()
t_decr.join()
print(a)
# Result: 0

import queue
q = queue.Queue(4)	# 實(shí)例化隊(duì)列對(duì)象, 并設(shè)置最大數(shù)據(jù)量

q.put('a')
q.put('b')
print(q.get()) # : a
print(q.get()) # : b
q.task_done() # get后必須要加task_done,確認(rèn)get操作是否完成

q.put(1)  # 當(dāng)前隊(duì)列已滿,再次put就會(huì)阻塞
print(q.full()) # 由于已經(jīng)阻塞, 所以這段不會(huì)被執(zhí)行
# put會(huì)在隊(duì)列慢了點(diǎn)時(shí)候，在插入值會(huì)發(fā)生阻塞
# get會(huì)在隊(duì)列里沒(méi)有值的時(shí)候，會(huì)發(fā)生阻塞

print(q.empty()) # 判斷隊(duì)列是否為空: True
q.put('test')
print(q.empty()) # : False

print(q.qsize()) # 當(dāng)前隊(duì)列里有多少人: 1

q.put(1)
q.put(1)
q.put(1)
print(q.full()) # : True

print('testetsetset')
q.join() # join會(huì)在隊(duì)列非空時(shí)發(fā)生阻塞
print('done') # 由于已經(jīng)阻塞, 所以這段不會(huì)被執(zhí)行

import queue
import threading
import time


class ThreadPool: # 自定義線程池

 def __init__(self, n): # 主線程做

 self.queue_obj = queue.Queue()
 for i in range(n):
  threading.Thread(target=self.worker, daemon=True).start() # 給子線程worker設(shè)置為守護(hù)模式

 def worker(self): # 子線程做，由于Debug調(diào)試的只是主線程的代碼，所以在調(diào)試時(shí)看不到子線程執(zhí)行的代碼
 """線程對(duì)象，寫while True 是為了能夠一直執(zhí)行任務(wù)。"""
 while True: # 讓線程執(zhí)行完一個(gè)任務(wù)之后不會(huì)死掉，主線程結(jié)束時(shí)，守護(hù)模式會(huì)讓worker里的死循環(huán)停止
  func = self.queue_obj.get() # get已經(jīng)入隊(duì)的任務(wù), 這里會(huì)接收到主線程分配的func
  # 由于設(shè)置了守護(hù)模式，當(dāng)隊(duì)列為空時(shí)，不會(huì)一直阻塞在get這里
  # 有了守護(hù)模式，worker會(huì)在主線程執(zhí)行完畢后死掉
  func() # 將隊(duì)列里的任務(wù)拿出來(lái)調(diào)用
  """
  這里func與task_done的順序非常重要，如果func放在task_done后面的話會(huì)出現(xiàn)只執(zhí)行兩次就結(jié)束。
  """
  self.queue_obj.task_done() # task_done 會(huì)刷新計(jì)數(shù)器
  # 線程池里有一個(gè)類似計(jì)數(shù)器的機(jī)制，用來(lái)記錄put的次數(shù)（+1），每一次task_done都會(huì)回?fù)芤淮斡涗浀拇螖?shù)（-1）
  # 當(dāng)回?fù)芡暧?jì)數(shù)器為0之后，就會(huì)執(zhí)行join

 def apply_async(self, func): # 主線程做
 """向隊(duì)列中傳入需要執(zhí)行的函數(shù)對(duì)象"""
 self.queue_obj.put(func) # 將接收到的func入隊(duì)

 def join(self): # 主線程做
 """等待隊(duì)列中的內(nèi)容被取完"""
 self.queue_obj.join() # 隊(duì)列里不為空就阻塞，為空就不阻塞

def task1(): # 子線程做
 time.sleep(2)
 print('task1 over')

def task2(): # 子線程做
 time.sleep(3)
 print('task2 over')

P = ThreadPool(2) # 如果在start開啟線程之后沒(méi)有傳入任務(wù)對(duì)象，worker里的get會(huì)直接阻塞
P.apply_async(task1)
P.apply_async(task2)

print('start')
P.join()
print('done')

# Result: 
start
task1 over
task2 over
done

from multiprocessing.pool import ThreadPool
import time

pool = ThreadPool(2) # 直接使用內(nèi)置線程池, 設(shè)置最大線程數(shù)

def task1():
 time.sleep(2)
 print('task1 over')

def task2(*args, **kwargs):
 time.sleep(3)
 print('task2 over', args, kwargs)

pool.apply_async(task1)
pool.apply_async(task2, args=(1, 2), kwds={'a': 1, 'b': 2})
print('Task Submitted')
pool.close() # 要點(diǎn): close必須要在join之前, 不允許再提交任務(wù)了
pool.join()
print('Mission Complete')

# Result:
Task Submitted
task1 over
task2 over (1, 2) {'a': 1, 'b': 2}
Mission Complete