import threading
import time

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

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

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

# Result:
one
two
I am Two	# 運行2s后
I am One	# 運行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)建線程實例
t1 = MyThread('One', 5)
t2 = MyThread('Two', 2)
# 啟動線程,實際上是調(diào)用了類中的run方法
t1.start()
t2.start()
t1.join()
print(t1.getName())
print(t2.getName())

# Result:
I am Two	# 運行后2s
I am One	# 運行后5s
One
Two

# 開始執(zhí)行, 這兩個線程會同步執(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ù)
t1 = threading.Thread(target=run, name='one', args=('One', 5))
t2 = threading.Thread(target=run, name='two', args=('Two', 2))
# 給t1設(shè)置守護模式, 使其隨著主線程的結(jié)束而結(jié)束
t1.setDaemon(True)
# 開始執(zhí)行, 這兩個線程會同步執(zhí)行
t1.start()
t2.start()	# 主線程會等待未設(shè)置守護模式的線程t2執(zhí)行完成

# Result:
I am Two	# 運行后2s

a = 0
def incr(n):
 global a
 for i in range(n):
 a += 1
# 這兩個方法同時聲明了變量a,并對其進行修改
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, 但是因為這里沒有設(shè)置互斥鎖, 所以兩個方法是同時對同一個變量進行修改, 得到的的結(jié)果值是隨機的

a = 0
lock = threading.Lock()	# 實例化互斥鎖對象, 方便之后的調(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, 自動解鎖
  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è)置最大數(shù)據(jù)量

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

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

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

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

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

print('testetsetset')
q.join() # join會在隊列非空時發(fā)生阻塞
print('done') # 由于已經(jīng)阻塞, 所以這段不會被執(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è)置為守護模式

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

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

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

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

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

P = ThreadPool(2) # 如果在start開啟線程之后沒有傳入任務(wù)對象，worker里的get會直接阻塞
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() # 要點: close必須要在join之前, 不允許再提交任務(wù)了
pool.join()
print('Mission Complete')

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