每個獨立的線程有一個程序運行的入口、順序執行序列和程序的出口。但是線程不能夠獨立執行，必須依存在應用程序中，由應用程序提供多個線程執行控制。

每個線程都有他自己的一組CPU寄存器，稱為線程的上下文，該上下文反映了線程上次運行該線程的CPU寄存器的狀態。

指令指針和堆棧指針寄存器是線程上下文中兩個最重要的寄存器，線程總是在進程得到上下文中運行的，這些地址都用于標志擁有線程的進程地址空間中的內存。

線程可以被搶占（中斷）。

在其他線程正在運行時，線程可以暫時擱置（也稱為睡眠） -- 這就是線程的退讓。

線程可以分為:

內核線程：由操作系統內核創建和撤銷。

用戶線程：不需要內核支持而在用戶程序中實現的線程。

Python3 線程中常用的兩個模塊為：

_thread

threading(推薦使用)

函數式

調用 _thread 模塊中的start_new_thread()函數來產生新線程。語法如下:

_thread.start_new_thread ( function, args[, kwargs] )

參數說明:

function - 線程函數。

args - 傳遞給線程函數的參數,他必須是個tuple類型。

kwargs - 可選參數。

import _thread, time# 定義線程函數def print_time(threadName, delay):

count = 0 while count < 5: ? ?

time.sleep(delay)

count += 1

# 返回當前時間的時間戳（1970紀元后經過的浮點秒數）, 并格式化輸出

print("{}: {}".format(threadName, time.ctime(time.time()) ))try:

_thread.start_new_thread( print_time, ("Thread-1", 2))

_thread.start_new_thread( print_time, ("Thread-2", 4))except:

print("Error")while 1: # 讓線程有足夠的時間完成 pass

E:\PyPro>python thread.pyThread-1: Thu Apr 12 09:01:56 2018Thread-2: Thu Apr 12 09:01:58 2018Thread-1: Thu Apr 12 09:01:58 2018Thread-1: Thu Apr 12 09:02:00 2018Thread-2: Thu Apr 12 09:02:02 2018Thread-1: Thu Apr 12 09:02:02 2018Thread-1: Thu Apr 12 09:02:05 2018Thread-2: Thu Apr 12 09:02:06 2018Thread-2: Thu Apr 12 09:02:10 2018Thread-2: Thu Apr 12 09:02:14 2018

類封裝式

threading 模塊除了包含 _thread 模塊中的所有方法外，還提供的其他方法：

threading.currentThread(): 返回當前的線程變量。

threading.enumerate(): 返回一個包含正在運行的線程的list。正在運行指線程啟動后、結束前，不包括啟動前和終止后的線程。

threading.activeCount(): 返回正在運行的線程數量，與len(threading.enumerate())有相同的結果。

線程模塊同樣提供了Thread類來處理線程，Thread類提供了以下方法:

run():用以表示線程活動的方法。

start():啟動線程活動。

join([time]):等待至線程中止。這阻塞調用線程直至線程的join() 方法被調用中止-正常退出或者拋出未處理的異常-或者是可選的超時發生。

isAlive():返回線程是否活動的。

getName():返回線程名。

setName():設置線程名。

import threading, time# 創建進程類class myThread(threading.Thread):

# 構造函數 def __init__(self, threadID, name, counter):

threading.Thread.__init__(self)

self.threadID = threadID

self.name = name

self.counter = counter

# 重寫run()

def run(self):

print("Thread Strat：" + self.name)

print_time(self.name, self.counter, 5)

print("Thread Exit：" + self.name)

def print_time(threadName, delay, counter):

while counter:

time.sleep(delay)

print("{}: {}".format(threadName, time.ctime(time.time()) ))

counter -= 1

# 創建線程thread1 = myThread(1001, "Thread-1", 1)thread2 = myThread(1002, "Thread-2", 2)# 開啟線程print("Thread-1 is Alive? ", thread1.isAlive())thread1.start()thread2.start()print("Thread-1 is Alive? ", thread1.isAlive())thread1.join()thread2.join()print("Thread-1 is Alive? ", thread1.isAlive())print("exit")

E:\PyPro>python threadClass.pyThread-1 is Alive? FalseThread Strat：

Thread-1Thread Strat：

Thread-2Thread-1 is Alive? TrueThread-1: Thu Apr 12 10:15:53 2018Thread-1:

Thu Apr 12 10:15:54 2018Thread-2: Thu Apr 12 10:15:54 2018Thread-1: Thu Apr 12 10:15:55 2018Thread-1:

Thu Apr 12 10:15:56 2018Thread-2: Thu Apr 12 10:15:56 2018Thread-1: Thu Apr 12 10:15:57 2018Thread Exit：

Thread-1Thread-2: Thu Apr 12 10:15:58 2018Thread-2: Thu Apr 12 10:16:00 2018Thread-2: Thu Apr 12 10:16:02 2018Thread Exit：

Thread-2Thread-1 is Alive? Falseexit

不難發現，線程是通過start()函數激活，而不是對象建立時激活的！

線程同步

多線程的優勢在于可以同時運行多個任務（至少感覺起來是這樣）。但是當線程需要共享數據時，可能存在數據不同步的問題。

使用 Thread 對象的 Lock 和 Rlock 可以實現簡單的線程同步，這兩個對象都有 acquire 方法和 release 方法，對于那些需要每次只允許一個線程操作的數據，可以將其操作放到 acquire 和 release 方法之間。

import threading, time# 創建鎖threadLock = threading.Lock()# 創建線程列表threads = []class myThread(threading.Thread):

def __init__(self, threadID, name, counter):

threading.Thread.__init__(self)

self.threadID = threadID

self.name = name

self.counter = counter

def run(self):

print("Thread Start: " + self.name)

# 獲取鎖，同步線程

threadLock.acquire()

print_time(self.name, self.counter, 3)

# 釋放鎖，開啟下一個線程

threadLock.release()

print("Thread Exit: " + self.name)

def print_time(threadName, delay, counter):

while counter:

time.sleep(delay)

print("{}: {}".format(threadName, time.ctime()))

counter -= 1

# 創建線程thread1 = myThread(1001, "Thread-1", 1)thread2 = myThread(1002, "Thread-2", 2)# 開啟線程thread1.start()thread2.start()# 添加線程列表threads.append(thread1)threads.append(thread2)# 等待所有線程完成for t in threads: t.join()print("exit")

E:\PyPro>python synchronize.pyThread Start: Thread-1Thread Start: Thread-2Thread-1: Thu Apr 12 11:00:49 2018Thread-1: Thu Apr 12 11:00:50 2018Thread-1: Thu Apr 12 11:00:51 2018Thread Exit: Thread-1Thread-2: Thu Apr 12 11:00:53 2018Thread-2: Thu Apr 12 11:00:55 2018Thread-2: Thu Apr 12 11:00:57 2018Thread Exit: Thread-2exit

線程優先級隊列

Python 的 Queue 模塊中提供了同步的、線程安全的隊列類，包括FIFO隊列Queue，LIFO隊列LifoQueue，和優先級隊列 PriorityQueue。

這些隊列都實現了鎖原語，能夠在多線程中直接使用，可以使用隊列來實現線程間的同步。

Queue 模塊中的常用方法:

Queue.qsize() 返回隊列的大小

Queue.empty() 如果隊列為空，返回True,反之False

Queue.full() 如果隊列滿了，返回True,反之False

Queue.full 與 maxsize 大小對應

Queue.get([block[, timeout]])獲取隊列，timeout等待時間

Queue.get_nowait() 相當Queue.get(False)

Queue.put(item) 寫入隊列，timeout等待時間

Queue.put_nowait(item) 相當Queue.put(item, False)

Queue.task_done() 在完成一項工作之后，Queue.task_done()函數向任務已經完成的隊列發送一個信號

Queue.join() 實際上意味著等到隊列為空，再執行別的操作

import queue, threading, timeexitFlag = 0# 創建鎖queueLock = threading.Lock()# 創建隊列workQueue = queue.Queue(10)class myThread(threading.Thread):

def __init__(self, threadID, name, q):

threading.Thread.__init__(self)

self.threadID = threadID

self.name = name

self.q = q

def run(self):

print("Thread Start: " + self.name)

process_data(self.name, self.q)

print("Thread Exit: " + self.name)

def process_data(threadName, q):

while not exitFlag:

queueLock.acquire()

if not workQueue.empty():

data = q.get()

queueLock.release()

print("{} processing {}".format(threadName, data))

else:

queueLock.release()

time.sleep(1)threadList = ["Thread-1", "Thread-2", "Thread-3"]nameList = ["One", "Two", "Three", "Four", "Five"]threads = []threadID = 1# 創建新線程for tName in threadList:

thread = myThread(threadID, tName, workQueue) thread.start() threads.append(thread)

threadID += 1# 填充隊列queueLock.acquire()print

("隊列填充中>>>>>>>>>>>>>>")time.sleep(1)for word in nameList: workQueue.put(word)print("隊列填充完畢>>>>>>>>>>>>>>")queueLock.release()# 等待隊列清空while not workQueue.empty(): pass# 通知線程退出exitFlag = 1# 等待所有線程完成for t in threads: t.join()print("exit")

E:\PyPro>python queueue.pyThread Start: Thread-1Thread Start: Thread-2Thread Start: Thread-3隊列填充中>>>>>>>>>>>>>>隊列填充完畢>>>>>>>>>>>>>>Thread-3 processing OneThread-1 processing TwoThread-2 processing ThreeThread-3 processing FourThread-1 processing FiveThread Exit: Thread-2Thread Exit: Thread-1Thread Exit: Thread-3exit

源碼中其實實現了三個進程讀取同一個隊列，按照先進先出原則實現鎖定。

用start方法來啟動線程，真正實現了多線程運行，這時無需等待run方法體代碼執行完畢而直接繼續執行下面的代碼。通過調用Thread類的start()方法來啟動一個線程，這時此線程處于就緒（可運行）狀態，并沒有運行，一旦得到cpu時間片，就開始執行run()方法，這里方法 run()稱為線程體，它包含了要執行的這個線程的內容，Run方法運行結束，此線程隨即終止。

join的作用是保證當前線程執行完成后，再執行其它線程。join可以有timeout參數，表示阻塞其它線程timeout秒后，不再阻塞。。一般線程的start()之后，所有操作結束后都要進行thread.join()。確保語句的輸出是join()后面的程序是等線程結束后再執行的。