線程是操作系統能夠進行運算調度的最小單位。它被包含在進程之中，是進程中的實際運作單位。一條線程指的是進程中一個單一順序的控制流，一個進程中可以並發多個線程，每條線程並行執行不同的任務
進程與線程
什么是線程（threading）？
A thread is an execution context, which is all the information a CPU needs to execute a stream of instructions.
Suppose you're reading a book, and you want to take a break right now, but you want to be able to come back and resume reading from the exact point where you stopped. One way to achieve that is by jotting down the page number, line number, and word number. So your execution context for reading a book is these 3 numbers.
If you have a roommate, and she's using the same technique, she can take the book while you're not using it, and resume reading from where she stopped. Then you can take it back, and resume it from where you were.
Threads work in the same way. A CPU is giving you the illusion that it's doing multiple computations at the same time. It does that by spending a bit of time on each computation. It can do that because it has an execution context for each computation. Just like you can share a book with your friend, many tasks can share a CPU.
On a more technical level, an execution context (therefore a thread) consists of the values of the CPU's registers.
Last: threads are different from processes. A thread is a context of execution, while a process is a bunch of resources associated with a computation. A process can have one or many threads.
Clarification: the resources associated with a process include memory pages (all the threads in a process have the same view of the memory), file descriptors (e.g., open sockets), and security credentials (e.g., the ID of the user who started the process).
線程的出現是為了降低上下文切換的消耗，提高系統的並發性，並突破一個進程只能干一樣事的缺陷，使到進程內並發成為可能。
假設，一個文本程序，需要接受鍵盤輸入，將內容顯示在屏幕上，還需要保存信息到硬盤中。若只有一個進程，勢必造成同一時間只能干一樣事的尷尬（當保存時，就不能通過鍵盤輸入內容）。若有多個進程，每個進程負責一個任務，進程A負責接收鍵盤輸入的任務，進程B負責將內容顯示在屏幕上的任務，進程C負責保存內容到硬盤中的任務。這里進程A，B，C間的協作涉及到了進程通信問題，而且有共同都需要擁有的東西——-文本內容，不停的切換造成性能上的損失。若有一種機制，可以使任務A，B，C共享資源，這樣上下文切換所需要保存和恢復的內容就少了，同時又可以減少通信所帶來的性能損耗，那就好了。是的，這種機制就是線程。
線程也叫輕量級進程，它是一個基本的CPU執行單元，也是程序執行過程中的最小單元，由線程ID、程序計數器、寄存器集合和堆棧共同組成。線程的引入減小了程序並發執行時的開銷，提高了操作系統的並發性能。線程沒有自己的系統資源。
什么是進程（process）？
An executing instance of a program is called a process.
Each process provides the resources needed to execute a program. A process has a virtual address space, executable code, open handles to system objects, a security context, a unique process identifier, environment variables, a priority class, minimum and maximum working set sizes, and at least one thread of execution. Each process is started with a single thread, often called the primary thread, but can create additional threads from any of its threads.
進程就是一個程序在一個數據集上的一次動態執行過程。進程一般由程序、數據集、進程控制塊三部分組成。我們編寫的程序用來描述進程要完成哪些功能以及如何完成；數據集則是程序在執行過程中所需要使用的資源；進程控制塊用來記錄進程的外部特征，描述進程的執行變化過程，系統可以利用它來控制和管理進程，它是系統感知進程存在的唯一標志。
舉一例說明進程：
想象一位有一手好廚藝的計算機科學家正在為他的女兒烘制生日蛋糕。他有做生日蛋糕的食譜，廚房里有所需的原料:面粉、雞蛋、糖、香草汁等。在這個比喻中，做蛋糕的食譜就是程序(即用適當形式描述的算法)計算機科學家就是處理器(cpu)，而做蛋糕的各種原料就是輸入數據。進程就是廚師閱讀食譜、取來各種原料以及烘制蛋糕等一系列動作的總和。現在假設計算機科學家的兒子哭着跑了進來，說他的頭被一只蜜蜂蟄了。計算機科學家就記錄下他照着食譜做到哪兒了(保存進程的當前狀態)，然后拿出一本急救手冊，按照其中的指示處理蟄傷。這里，我們看到處理機從一個進程(做蛋糕)切換到另一個高優先級的進程(實施醫療救治)，每個進程擁有各自的程序(食譜和急救手冊)。當蜜蜂蟄傷處理完之后，這位計算機科學家又回來做蛋糕，從他離開時的那一步繼續做下去。
進程與線程之間的區別？
A thread is an execution context, which is all the information a CPU needs to execute a stream of instructions.
Suppose you're reading a book, and you want to take a break right now, but you want to be able to come back and resume reading from the exact point where you stopped. One way to achieve that is by jotting down the page number, line number, and word number. So your execution context for reading a book is these 3 numbers.
If you have a roommate, and she's using the same technique, she can take the book while you're not using it, and resume reading from where she stopped. Then you can take it back, and resume it from where you were.
Threads work in the same way. A CPU is giving you the illusion that it's doing multiple computations at the same time. It does that by spending a bit of time on each computation. It can do that because it has an execution context for each computation. Just like you can share a book with your friend, many tasks can share a CPU.
On a more technical level, an execution context (therefore a thread) consists of the values of the CPU's registers.
Last: threads are different from processes. A thread is a context of execution, while a process is a bunch of resources associated with a computation. A process can have one or many threads.
Clarification: the resources associated with a process include memory pages (all the threads in a process have the same view of the memory), file descriptors (e.g., open sockets), and security credentials (e.g., the ID of the user who started the process).
進程是計算機中的程序關於某數據集合上的一次運行活動，是系統進行資源分配和調度的基本單位，是操作系統結構的基礎。或者說進程是具有一定獨立功能的程序關於某個數據集合上的一次運行活動,進程是系統進行資源分配和調度的一個獨立單位。
線程則是進程的一個實體,是CPU調度和分派的基本單位,它是比進程更小的能獨立運行的基本單位。
進程和線程的關系：
(1)一個線程只能屬於一個進程，而一個進程可以有多個線程，但至少有一個線程。
(2)資源分配給進程，同一進程的所有線程共享該進程的所有資源。
(3)CPU分給線程，即真正在CPU上運行的是線程。
並行與並發
並行處理（Parallel Processing）是計算機系統中能同時執行兩個或者更多個處理的一種計算方法。並行處理可同時工作於同一程序的不同方面，並行處理的主要目的是節省大型和復雜問題的解決時間。
並發處理（concurrency Processing）是指一個時間段中有幾個程序都處於已經啟動運行到運行完畢之間，而且這幾個程序都是在同一處理機（CPU）上運行，但任意時刻點上只有一個程序在處理機（CPU）上運行
並發的關鍵在於你有處理多個任務的能力，不一定同時，並行的關鍵是你有同時處理多個任務的能力，所以說，並行是並發的子集
同步與異步
在計算機領域，同步就是指一個進程在執行某個請求的時候，若該請求需要一段時間才能返回信息，那么這個進程將會一直等待下去，直到收到返回信息才繼續執行下去；異步是指進程不需要一直等下去，而是繼續執行下面的操作，不管其他進程的狀態。當有消息返回時系統會通知進程進行處理，這樣可以提高執行的效率。舉個例子，打電話時就是同步通信，發短息時就是異步通信。
線程（Thread）類的實例方法
join和Daemon
join()：在子線程完成運行之前，這個子線程的父線程將一直被阻塞。
setDaemon(True)：
將線程聲明為守護線程，必須在start() 方法調用之前設置， 如果不設置為守護線程程序會被無限掛起。這個方法基本和join是相反的。當我們 在程序運行中，執行一個主線程，如果主線程又創建一個子線程，主線程和子線程 就分兵兩路，分別運行，那么當主線程完成想退出時，會檢驗子線程是否完成。如 果子線程未完成，則主線程會等待子線程完成后再退出。但是有時候我們需要的是 只要主線程完成了，不管子線程是否完成，都要和主線程一起退出，這時就可以 用setDaemon方法啦
# join()：在子線程完成運行之前，這個子線程的父線程將一直被阻塞。
# setDaemon(True)：
'''
將線程聲明為守護線程，必須在start() 方法調用之前設置，如果不設置為守護線程程序會被無限掛起。
當我們在程序運行中，執行一個主線程，如果主線程又創建一個子線程，主線程和子線程 就分兵兩路，分別運行，那么當主線程完成
想退出時，會檢驗子線程是否完成。如果子線程未完成，則主線程會等待子線程完成后再退出。但是有時候我們需要的是只要主線程
完成了，不管子線程是否完成，都要和主線程一起退出，這時就可以 用setDaemon方法啦'''
import threading
from time import ctime,sleep
import time
def Music(name):
print ("Begin listening to {name}. {time}".format(name=name,time=ctime()))
sleep(3)
print("end listening {time}".format(time=ctime()))
def Blog(title):
print ("Begin recording the {title}. {time}".format(title=title,time=ctime()))
sleep(5)
print('end recording {time}'.format(time=ctime()))
threads = []
t1 = threading.Thread(target=Music,args=('FILL ME',))
t2 = threading.Thread(target=Blog,args=('',))
threads.append(t1)
threads.append(t2)
if __name__ == '__main__':
#t2.setDaemon(True)
for t in threads:
#t.setDaemon(True) #注意:一定在start之前設置
t.start()
#t.join()
#t1.join()
#t2.join() # 考慮這三種join位置下的結果？
print ("all over %s" %ctime())
daemon A boolean value indicating whether this thread is a daemon thread (True) or not (False). This must be set before start() is called, otherwise RuntimeError is raised. Its initial value is inherited from the creating thread; the main thread is not a daemon thread and therefore all threads created in the main thread default to daemon = False. The entire Python program exits when no alive non-daemon threads are left. 當daemon被設置為True時，如果主線程退出，那么子線程也將跟着退出， 反之，子線程將繼續運行，直到正常退出。 daemon
其他方法
Thread實例對象的方法 # isAlive(): 返回線程是否活動的。 # getName(): 返回線程名。 # setName(): 設置線程名。 threading模塊提供的一些方法： # threading.currentThread(): 返回當前的線程變量。 # threading.enumerate(): 返回一個包含正在運行的線程的list。正在運行指線程啟動后、結束前，不包括啟動前和終止后的線程。 # threading.activeCount(): 返回正在運行的線程數量，與len(threading.enumerate())有相同的結果。
python GIL（global Interper Lack）是什么？
GIL的概念
GIL全稱是全局解釋器鎖，來源是python設計之初的考慮，為了數據安全所做的決定
每個CPU在同一時期只能執行一個線程（在單核CPU下的多線程其實都只是並發的，不是並行，並行和並發從宏觀上來講都是同時處理多路請求的概念。但是並發和並行又有區別，並行是指兩個或者多個事件在同一時刻發生；而並發是指兩個或者多個事件在同一時間間隔內發生）
CPython implementation detail: In CPython, due to the Global Interpreter Lock, only one thread can execute Python code at once (even though certain performance-oriented libraries might overcome this limitation). If you want your application to make better use of the computational resources of multi-core machines, you are advised to use multiprocessing. However, threading is still an appropriate model if you want to run multiple I/O-bound tasks simultaneously.
GIL的早期設計
Python支持多線程，而解決多線程之間數據完整性和狀態同步的最簡單方法自然就是加鎖。 於是有了GIL這把超級大鎖，而當越來越多的代碼庫開發者接受了這種設定后，他們開始大量依賴這種特性（即默認python內部對象是thread-safe的，無需在實現時考慮額外的內存鎖和同步操作）。慢慢的這種實現方式被發現是蛋疼且低效的。但當大家試圖去拆分和去除GIL的時候，發現大量庫代碼開發者已經重度依賴GIL而非常難以去除了。有多難？做個類比，像MySQL這樣的“小項目”為了把Buffer Pool Mutex這把大鎖拆分成各個小鎖也花了從5.5到5.6再到5.7多個大版為期近5年的時間，並且仍在繼續。MySQL這個背后有公司支持且有固定開發團隊的產品走的如此艱難，那又更何況Python這樣核心開發和代碼貢獻者高度社區化的團隊呢？
GIL的影響
在python多線程下，每個線程的執行方式：
（1）獲取GIL
（2）執行代碼直到sleep或者是python虛擬機將其掛起
（3）釋放GIL
可見，某個線程想要執行，必須先拿到GIL，我們可以將GIL看作是“通行證”，並且在一個python進程中，GIL只有一個，拿不到通行證的線程，就不允許進入CPU執行。
而每次釋放GIL鎖，線程進行鎖競爭，切換線程，會消耗資源。並且由於GIL鎖存在，python里一個進程永遠只能同時執行一個線程（拿到GIL的線程才能執行），這就是為什么在多核CPU上，python的多線程效率並不高的原因。
那么是不是python的多線程就完全沒有作用了呢？
在這里我們分類討論：
（1）：CPU密集型代碼：又稱計算密集型任務，是指CPU計算占主要的任務，CPU一直處於滿負荷的狀態，比如在一個很大的列表中查找元素（當然這不合理），復雜的加減乘除等
（各種循環處理，計數等等），在這種情況下，ticks計數很快會達到闕值，然后觸發GIL的釋放與再競爭（多個線程來回切換當然是需要消耗資源的），所以python下的多線程對CPU密集型代碼並不友好。
（2）：IO密集型代碼：指磁盤IO，網絡IO占主要的任務，計算量很小。比如請求網頁，讀取文件等，當然我們可以在python中可以利用sleep達到IO密集型任務的目的
（文件處理，網絡爬蟲等），多線程能夠有效的提升效率（單線程下有IO操作會進行IO等待，造成不必要的時間浪費，而開啟多線程能在線程A等待的時候，自動切換到線程B，可以不浪費CPU資源，從而能提升程序代碼執行效率），所以python的多線程對IO密集型代碼比較友好。
在python3.x中GIL不適用ticks計數，改為使用計時器（執行時間達到闕值后，當前線程釋放GIL），這樣對CPU密集型程序更加友好，但是依然沒有解決GIL導致的同一時間只能執行一個線程的問題，所以效率依然不盡人意
多核多線程比單核多線程更差，原因是單核下多線程，每次釋放GIL，喚醒的那個線程都能獲取到GIL鎖，所以能夠無縫執行，但是在多核下導致其他幾個COU上被喚醒后的線程會醒着等待到切換時間后又進入到待調度狀態，這樣會造成線程顛簸，導致效率更低。
所以說“python下想要充分使用多核CPU，就要利用多進程”的原因是什么呢？
每個進程都有各自獨立的GIL，互不干擾，這樣就可以真正意義上並行執行，所以在python中，多進程的執行效率優於多線程，（僅僅針對多核CPU）
故我們得出結論：多核下，想要並行提升效率，比較通用的方法是使用多進程，能夠有效的提高執行效率。
#coding:utf8
from threading import Thread
import time
def counter():
i = 0
for _ in range(50000000):
i = i + 1
return True
def main():
l=[]
start_time = time.time()
for i in range(2):
t = Thread(target=counter)
t.start()
l.append(t)
t.join()
# for t in l:
# t.join()
end_time = time.time()
print("Total time: {}".format(end_time - start_time))
if __name__ == '__main__':
main()
'''
py2.7:
串行:25.4523348808s
並發:31.4084379673s
py3.5:
串行:8.62115597724914s
並發:8.99609899520874s
'''
多進程
多進程的概念
multiprocessing is a package that supports spawning processes using an API similar to the threading module. The multiprocessing package offers both local and remote concurrency,effectively side-stepping the Global Interpreter Lock by using subprocesses instead of threads. Due to this, the multiprocessing module allows the programmer to fully leverage multiple processors on a given machine. It runs on both Unix and Windows.
由於GIL的存在，python中的多線程其實並不是真正的多線程，如果想要充分地使用多核CPU的資源，在python中大部分情況需要使用多進程。Python提供了非常好用的多進程包multiprocessing，只需要定義一個函數，Python會完成其他所有事情。借助這個包，可以輕松完成從單進程到並發執行的轉換。multiprocessing支持子進程、通信和共享數據、執行不同形式的同步，提供了Process、Queue、Pipe、Lock等組件。
multiprocessing包是Python中的多進程管理包。與threading.Thread類似，它可以利用multiprocessing.Process對象來創建一個進程。該進程可以運行在Python程序內部編寫的函數。該Process對象與Thread對象的用法相同，也有start(), run(), join()的方法。此外multiprocessing包中也有Lock/Event/Semaphore/Condition類 (這些對象可以像多線程那樣，通過參數傳遞給各個進程)，用以同步進程，其用法與threading包中的同名類一致。所以，multiprocessing的很大一部份與threading使用同一套API，只不過換到了多進程的情境。
但在使用這些共享API的時候，我們要注意以下幾點:
- 在UNIX平台上，當某個進程終結之后，該進程需要被其父進程調用wait，否則進程成為僵屍進程(Zombie)。所以，有必要對每個Process對象調用join()方法 (實際上等同於wait)。對於多線程來說，由於只有一個進程，所以不存在此必要性。
- multiprocessing提供了threading包中沒有的IPC(比如Pipe和Queue)，效率上更高。應優先考慮Pipe和Queue，避免使用Lock/Event/Semaphore/Condition等同步方式 (因為它們占據的不是用戶進程的資源)。
- 多進程應該避免共享資源。在多線程中，我們可以比較容易地共享資源，比如使用全局變量或者傳遞參數。在多進程情況下，由於每個進程有自己獨立的內存空間，以上方法並不合適。此時我們可以通過共享內存和Manager的方法來共享資源。但這樣做提高了程序的復雜度，並因為同步的需要而降低了程序的效率。
Process.PID中保存有PID，如果進程中還沒有start()，則PID為None。
windows系統下，需要注意的是想要啟動一個子進程必須加上
if __name__ ="__main__"
進程相關要寫在上面這句語句下面。
舉個例子：
from multiprocessing import Process
import time
def f(name):
time.sleep(1)
print('hello', name,time.ctime())
if __name__ == '__main__':
p_list=[]
for i in range(3):
p = Process(target=f, args=('alvin',))
p_list.append(p)
p.start()
for i in p_list:
p.join()
print('end')
類式調用
from multiprocessing import Process
import time
class MyProcess(Process):
def __init__(self):
super(MyProcess, self).__init__()
#self.name = name
def run(self):
time.sleep(1)
print ('hello', self.name,time.ctime())
if __name__ == '__main__':
p_list=[]
for i in range(3):
p = MyProcess()
p.start()
p_list.append(p)
for p in p_list:
p.join()
print('end')
Process類
構造方法
Process([group [, target [, name [, args [, kwargs]]]]])
group: 線程組，目前還沒有實現，庫引用中提示必須是None；
target: 要執行的方法；
name: 進程名；
args/kwargs: 要傳入方法的參數。
實例方法
is_alive()：返回進程是否在運行。
join([timeout])：阻塞當前上下文環境的進程程，直到調用此方法的進程終止或到達指定的timeout（可選參數）。
start()：進程准備就緒，等待CPU調度
run()：strat()調用run方法，如果實例進程時未制定傳入target，這star執行t默認run()方法。
terminate()：不管任務是否完成，立即停止工作進程
屬性
authkey
daemon：和線程的setDeamon功能一樣
exitcode(進程在運行時為None、如果為–N，表示被信號N結束）
name：進程名字。
pid：進程號。
import time
from multiprocessing import Process
def foo(i):
time.sleep(1)
print (p.is_alive(),i,p.pid)
time.sleep(1)
if __name__ == '__main__':
p_list=[]
for i in range(10):
p = Process(target=foo, args=(i,))
#p.daemon=True
p_list.append(p)
for p in p_list:
p.start()
# for p in p_list:
# p.join()
print('main process end')
進程間通訊
不同進程間內存是不共享的，要想實現兩個進程間的數據交換，可以用以下方法：
——進程隊列Queues（使用方法跟threading里的queue類似：）
from multiprocessing import Process, Queue
def f(q,n):
q.put([42, n, 'hello'])
if __name__ == '__main__':
q = Queue()
p_list=[]
for i in range(3):
p = Process(target=f, args=(q,i))
p_list.append(p)
p.start()
print(q.get())
print(q.get())
print(q.get())
for i in p_list:
i.join()
——管道Pipe
from multiprocessing import Process, Pipe
def f(conn):
conn.send([42, None, 'hello'])
conn.close()
if __name__ == '__main__':
parent_conn, child_conn = Pipe()
p = Process(target=f, args=(child_conn,))
p.start()
print(parent_conn.recv()) # prints "[42, None, 'hello']"
p.join()
——managers
from multiprocessing import Process, Manager
def f(d, l,n):
d[n] = '1'
d['2'] = 2
d[0.25] = None
l.append(n)
print(l)
if __name__ == '__main__':
with Manager() as manager:
d = manager.dict()
l = manager.list(range(5))
p_list = []
for i in range(10):
p = Process(target=f, args=(d, l,i))
p.start()
p_list.append(p)
for res in p_list:
res.join()
print(d)
print(l)
進程同步
from multiprocessing import Process, Lock
def f(l, i):
l.acquire()
try:
print('hello world', i)
finally:
l.release()
if __name__ == '__main__':
lock = Lock()
for num in range(10):
Process(target=f, args=(lock, num)).start()
進程池
進程池內部維護一個進程序列，當使用時，去進程池中獲取一個進程，如果進程池序列中沒有可供使用的進程，那么程序就會等待，直到進程池中有可用進程為止。
進程池中有以下幾個主要方法：
- apply：從進程池里取一個進程並執行
- apply_async：apply的異步版本
- terminate:立刻關閉線程池
- join：主進程等待所有子進程執行完畢，必須在close或terminate之后
- close：等待所有進程結束后，才關閉線程池
from multiprocessing import Process,Pool
import time
def Foo(i):
time.sleep(2)
return i+100
def Bar(arg):
print('-->exec done:',arg)
pool = Pool(5)
for i in range(10):
pool.apply_async(func=Foo, args=(i,),callback=Bar)
#pool.apply(func=Foo, args=(i,))
print('end')
pool.close()
pool.join()
https://www.cnblogs.com/zingp/p/5878330.html