A. python多線程對多核的利用
GIL 與 Python 線程的糾葛
GIL 是什麼東西？它對我們的 python 程序會產生什麼樣的影響？我們先來看一個問題。運行下面這段 python 程序，CPU 佔用率是多少？
# 請勿在工作中模仿，危險:)
def dead_loop():
while True:
pass
dead_loop()
答案是什麼呢，佔用 100％ CPU？那是單核！還得是沒有超線程的古董 CPU。在我的雙核 CPU 上，這個死循環只會吃掉我一個核的工作負荷，也就是只佔用 50％ CPU。那如何能讓它在雙核機器上佔用 100％ 的 CPU 呢？答案很容易想到，用兩個線程就行了，線程不正是並發分享 CPU 運算資源的嗎。可惜答案雖然對了，但做起來可沒那麼簡單。下面的程序在主線程之外又起了一個死循環的線程
import threading
def dead_loop():
while True:
pass
# 新起一個死循環線程
t = threading.Thread(target=dead_loop)
t.start()
# 主線程也進入死循環
dead_loop()
t.join()
按道理它應該能做到佔用兩個核的 CPU 資源，可是實際運行情況卻是沒有什麼改變，還是只佔了 50％ CPU 不到。這又是為什麼呢？難道 python 線程不是操作系統的原生線程？打開 system monitor 一探究竟，這個佔了 50% 的 python 進程確實是有兩個線程在跑。那這兩個死循環的線程為何不能占滿雙核 CPU 資源呢？其實幕後的黑手就是 GIL。
GIL 的迷思：痛並快樂著
GIL 的全稱為 Global Interpreter Lock ，意即全局解釋器鎖。在 Python 語言的主流實現 CPython 中，GIL 是一個貨真價實的全局線程鎖，在解釋器解釋執行任何 Python 代碼時，都需要先獲得這把鎖才行，在遇到 I/O 操作時會釋放這把鎖。如果是純計算的程序，沒有 I/O 操作，解釋器會每隔 100 次操作就釋放這把鎖，讓別的線程有機會執行（這個次數可以通過sys.setcheckinterval 來調整）。所以雖然 CPython 的線程庫直接封裝操作系統的原生線程，但 CPython 進程做為一個整體，同一時間只會有一個獲得了 GIL 的線程在跑，其它的線程都處於等待狀態等著 GIL 的釋放。這也就解釋了我們上面的實驗結果：雖然有兩個死循環的線程，而且有兩個物理 CPU 內核，但因為 GIL 的限制，兩個線程只是做著分時切換，總的 CPU 佔用率還略低於 50％。
看起來 python 很不給力啊。GIL 直接導致 CPython 不能利用物理多核的性能加速運算。那為什麼會有這樣的設計呢？我猜想應該還是歷史遺留問題。多核 CPU 在 1990 年代還屬於類科幻，Guido van Rossum 在創造 python 的時候，也想不到他的語言有一天會被用到很可能 1000＋ 個核的 CPU 上面，一個全局鎖搞定多線程安全在那個時代應該是最簡單經濟的設計了。簡單而又能滿足需求，那就是合適的設計（對設計來說，應該只有合適與否，而沒有好與不好）。怪只怪硬體的發展實在太快了，摩爾定律給軟體業的紅利這么快就要到頭了。短短 20 年不到，代碼工人就不能指望僅僅靠升級 CPU 就能讓老軟體跑的更快了。在多核時代，編程的免費午餐沒有了。如果程序不能用並發擠干每個核的運算性能，那就意謂著會被淘汰。對軟體如此，對語言也是一樣。那 Python 的對策呢？
Python 的應對很簡單，以不變應萬變。在最新的 python 3 中依然有 GIL。之所以不去掉，原因嘛，不外以下幾點：
欲練神功，揮刀自宮：
CPython 的 GIL 本意是用來保護所有全局的解釋器和環境狀態變數的。如果去掉 GIL，就需要多個更細粒度的鎖對解釋器的眾多全局狀態進行保護。或者採用 Lock-Free 演算法。無論哪一種，要做到多線程安全都會比單使用 GIL 一個鎖要難的多。而且改動的對象還是有 20 年歷史的 CPython 代碼樹，更不論有這么多第三方的擴展也在依賴 GIL。對 Python 社區來說，這不異於揮刀自宮，重新來過。
就算自宮，也未必成功：
有位牛人曾經做了一個驗證用的 CPython，將 GIL 去掉，加入了更多的細粒度鎖。但是經過實際的測試，對單線程程序來說，這個版本有很大的性能下降，只有在利用的物理 CPU 超過一定數目後，才會比 GIL 版本的性能好。這也難怪。單線程本來就不需要什麼鎖。單就鎖管理本身來說，鎖 GIL 這個粗粒度的鎖肯定比管理眾多細粒度的鎖要快的多。而現在絕大部分的 python 程序都是單線程的。再者，從需求來說，使用 python 絕不是因為看中它的運算性能。就算能利用多核，它的性能也不可能和 C/C++ 比肩。費了大力氣把 GIL 拿掉，反而讓大部分的程序都變慢了，這不是南轅北轍嗎。
難道 Python 這么優秀的語言真的僅僅因為改動困難和意義不大就放棄多核時代了嗎？其實，不做改動最最重要的原因還在於：不用自宮，也一樣能成功！
其它神功
那除了切掉 GIL 外，果然還有方法讓 Python 在多核時代活的滋潤？讓我們回到本文最初的那個問題：如何能讓這個死循環的 Python 腳本在雙核機器上佔用 100％ 的 CPU？其實最簡單的答案應該是：運行兩個 python 死循環的程序！也就是說，用兩個分別占滿一個 CPU 內核的 python 進程來做到。確實，多進程也是利用多個 CPU 的好方法。只是進程間內存地址空間獨立，互相協同通信要比多線程麻煩很多。有感於此，Python 在 2.6 里新引入了 multiprocessing這個多進程標准庫，讓多進程的 python 程序編寫簡化到類似多線程的程度，大大減輕了 GIL 帶來的不能利用多核的尷尬。
這還只是一個方法，如果不想用多進程這樣重量級的解決方案，還有個更徹底的方案，放棄 Python，改用 C/C++。當然，你也不用做的這么絕，只需要把關鍵部分用 C/C++ 寫成 Python 擴展，其它部分還是用 Python 來寫，讓 Python 的歸 Python，C 的歸 C。一般計算密集性的程序都會用 C 代碼編寫並通過擴展的方式集成到 Python 腳本里（如 NumPy 模塊）。在擴展里就完全可以用 C 創建原生線程，而且不用鎖 GIL，充分利用 CPU 的計算資源了。不過，寫 Python 擴展總是讓人覺得很復雜。好在 Python 還有另一種與 C 模塊進行互通的機制 : ctypes
利用 ctypes 繞過 GIL
ctypes 與 Python 擴展不同，它可以讓 Python 直接調用任意的 C 動態庫的導出函數。你所要做的只是用 ctypes 寫些 python 代碼即可。最酷的是，ctypes 會在調用 C 函數前釋放 GIL。所以，我們可以通過 ctypes 和 C 動態庫來讓 python 充分利用物理內核的計算能力。讓我們來實際驗證一下，這次我們用 C 寫一個死循環函數
extern"C"
{
void DeadLoop()
{
while (true);
}
}
用上面的 C 代碼編譯生成動態庫 libdead_loop.so （Windows 上是 dead_loop.dll）
，接著就要利用 ctypes 來在 python 里 load 這個動態庫，分別在主線程和新建線程里調用其中的 DeadLoop
from ctypes import *
from threading import Thread
lib = cdll.LoadLibrary("libdead_loop.so")
t = Thread(target=lib.DeadLoop)
t.start()
lib.DeadLoop()
這回再看看 system monitor，Python 解釋器進程有兩個線程在跑，而且雙核 CPU 全被占滿了，ctypes 確實很給力！需要提醒的是，GIL 是被 ctypes 在調用 C 函數前釋放的。但是 Python 解釋器還是會在執行任意一段 Python 代碼時鎖 GIL 的。如果你使用 Python 的代碼做為 C 函數的 callback，那麼只要 Python 的 callback 方法被執行時，GIL 還是會跳出來的。比如下面的例子：
extern"C"
{
typedef void Callback();
void Call(Callback* callback)
{
callback();
}
}
from ctypes import *
from threading import Thread
def dead_loop():
while True:
pass
lib = cdll.LoadLibrary("libcall.so")
Callback = CFUNCTYPE(None)
callback = Callback(dead_loop)
t = Thread(target=lib.Call, args=(callback,))
t.start()
lib.Call(callback)
注意這里與上個例子的不同之處，這次的死循環是發生在 Python 代碼里 (DeadLoop 函數) 而 C 代碼只是負責去調用這個 callback 而已。運行這個例子，你會發現 CPU 佔用率還是只有 50％ 不到。GIL 又起作用了。
其實，從上面的例子，我們還能看出 ctypes 的一個應用，那就是用 Python 寫自動化測試用例，通過 ctypes 直接調用 C 模塊的介面來對這個模塊進行黑盒測試，哪怕是有關該模塊 C 介面的多線程安全方面的測試，ctypes 也一樣能做到。
結語
雖然 CPython 的線程庫封裝了操作系統的原生線程，但卻因為 GIL 的存在導致多線程不能利用多個 CPU 內核的計算能力。好在現在 Python 有了易經筋（multiprocessing）, 吸星大法（C 語言擴展機制）和獨孤九劍（ctypes），足以應付多核時代的挑戰，GIL 切還是不切已經不重要了，不是嗎。
B. Python和go語言有什麼區別哪個更有優勢
python和go語言的區別
1、語法
Python的語法使用縮進來指示代碼塊。Go的語法基於打開和關閉括弧。
2、範例
Python是一種基於面向對象編程的多範式，命令式和函數式編程語言。它堅持這樣一種觀點，即如果一種語言在某些情境中表現出某種特定的方式，理想情況下它應該在所有情境中都有相似的作用。但是，它又不是純粹的OOP語言，它不支持強封裝，這是OOP的主要原則之一。
Go是一種基於並發編程範式的過程編程語言，它與C具有表面相似性。實際上，Go更像是C的更新版本。
3、並發
Python沒有提供內置的並發機制，而Go有內置的並發機制。
4、類型化
Python是動態類型語言，而Go是一種靜態類型語言，它實際上有助於在編譯時捕獲錯誤，這可以進一步減少生產後期的嚴重錯誤。
5、安全性
Python是一種強類型語言，它是經過編譯的，因此增加了一層安全性。Go具有分配給每個變數的類型，因此，它提供了安全性。但是，如果發生任何錯誤，用戶需要自己運行整個代碼。
6、管理內存
Go允許程序員在很大程度上管理內存。而，Python中的內存管理完全自動化並由Python VM管理；它不允許程序員對內存管理負責。
7、庫
與Go相比，Python提供的庫數量要大得多。然而，Go仍然是新的，並且還沒有取得很大進展。
8、速度：
Go的速度遠遠超過Python。
C. Python有什麼缺點呢
1. - 運行速度慢，因為Python是解釋型語言，是一種高級語言，代碼會在執行的時候，一行一行的使用解釋器翻譯成底層代碼，翻譯成機器碼，而這個過程非常耗時，所以他運行過程中，比很多語言的代碼都慢了很多。
- 線程不能利用多CPU，這是Python最大的確定，GIL即全局解釋器鎖（Global Interpreter Lock），是計算機程序設計語言解釋器用於同步線程的工具，使得任何時刻僅有一個線程在執行，Python的線程是操作系統的原生線程。在linux上為pthread，在Windows上為Win thread，完全由操作系統調度線程的執行。一個python解釋器進程內有一條主線程，以及多條用戶程序的執行線程。即使在多核CPU平台上，由於GIL的存在，所以禁止多線程的並行執行。
Python的優缺點可以看看傳智播客的社區，裡面很多技術老師寫的相關文章。並且有學習線路圖適合小白學習，每個板塊下面都有配套視頻。
D. python如何利用多核cpu
你需要利用javaScript，然後才能夠直接使用這個多核的CPU用編程的語言。
E. python同時打開幾個程序默認運行哪一個
操作系統的作用
隱藏醜陋復雜的硬體介面，提供良好的抽象介面
管理、調度進程，並且將多個進程對硬體的競爭變得有序
2. 多道技術產生背景
針對單核，實現並發
現在的主機一般是多核，那麼每個核都會利用多道技術
有 4 個 cpu，運行於 cpu1 的某個程序遇到 io 阻塞，會等到 io 結束再重新調度
會被調度到 4 個 cpu 中的任意一個，具體由操作系統調度演算法決定
3. 多道技術空間上的復用：如內存中同時有多道程序
4. 多道技術時間上的復用
復用一個 cpu 的時間片
注意，遇到 io 切，佔用 cpu 時間過長也切
核心在於切之前將進程的狀態保存下來
這樣才能保證下次切換回來時，能基於上次切走的位置繼續運行
進程的概念
進程是一個具有一定獨立功能的程序關於某個數據集合的一次運行活動
進程是操作系統動態執行的基本單元
在傳統的操作系統中，進程既是基本的分配單元，也是基本的執行單元
進程與程序的區別
程序是指令和數據的有序集合，是一個靜態的概念。程序可以作為一種軟體資料長期存在，是永久的
進程是程序在處理機上的一次執行過程,它是一個動態的概念。進程是有一定生命期的，是暫時的
5. 注意：同一個程序執行兩次，就會在操作系統中出現兩個進程。所以可以同時運行一個軟體，分別做不同的事情也不會混亂，比如可以打開兩個Pycharm做不同的事
6. 進程調度
要想多個進程交替運行，操作系統必須對這些進程進行調度
這個調度也不是隨即進行的，而是需要遵循一定的法則
由此就有了進程的調度演算法：先來先服務調度演算法、短作業優先調度演算法、時間片輪轉法、多級反饋隊列
並行和並發
並行是指在一個時間點上，有多個進程在被 cpu 計算，比如賽跑，兩個人都在不停的往前跑
並發是指資源有限的情況下，在一個時間段上，有多個進程在被 cpu 計算，交替輪流使用資源
並行與並發的區別
並行是從微觀上，也就是在一個精確的時間片刻，有不同的程序在執行，這就要求必須有多個處理器
並發是從宏觀上，在一個時間段上可以看出是同時執行的，比如一個伺服器同時處理多個 session
進程的三狀態
在程序運行的過程中，由於被操作系統的調度演算法控制，程序會進入幾個狀態
就緒
運行
阻塞
2. 舉例說明什麼是 argv，什麼是阻塞
import sys
print(sys.argv)
# 運行結果：
['G:/course_select/進程的概念.py']
# argv 指參數
# sys.argv 是 Python 解釋器在運行的時候傳遞進來的參數
# 首先在cmd輸入以下信息：
python G:/course_select/進程的概念.py
# 列印結果：
['G:/course_select/進程的概念.py']
# 然後在cmd中切換路徑到G盤，接著輸入 python course_select/進程的概念.py
# 列印結果：
['course_select/進程的概念.py']
# 接著，再在cmd中輸入：python course_select/進程的概念.py 123 abc
# 列印結果：
['course_select/進程的概念.py', '123', 'abc']
# 因此，以下程序不能在編輯器里運行，只能在 cmd 裡面使用 Python 運行本文件
# 然後要在後面加上 aaa bbb
# 就像上面的 python course_select/進程的概念.py 123 abc 一樣
if sys.argv[1] == "aaa" and sys.argv[2] == "bbb":
print("登錄成功")
else:
print("登錄失敗")
exit()
print(666)
# 而如果使用input(),其實就是一種阻塞
3. 進程的三狀態圖
.png
同步非同步
同步：形象的說，一件事的執行必須依賴另一件事的結束，強調的是順序性
非同步： 形象的說，兩件事情可以同時進行
注意：同步非同步和並行、並發沒關系
阻塞：等待，比如 input sleep recv accept recvfrom
非阻塞：不等待，start/terminate 都是非阻塞的
阻塞與非阻塞主要是從程序（線程）等待消息通知時的狀態角度來說的
可以分為四類：
同步阻塞
非同步阻塞
同步非阻塞
非同步非阻塞
start/terminate 都是非阻塞的
進程模塊
跟進程相關的基本都在這個模塊里：multiprocessing
父進程與子進程的對比分析
父進程，比如運行本文件
子進程，運行 Process(target=func).start()
父進程與子進程數據隔離
主進程等待子進程結束之後再結束
子進程和主進程之間默認是非同步的
from multiprocessing import Process
import time
def func():
time.sleep(1)
print(666)
if __name__ == "__main__":
# 開啟了一個新的進程，在這個新的進程里執行的 func()
Process(target=func).start()
time.sleep(1)
# 主進程
print(777)
# 777
# 666
# 運行結果仔細觀察發現有非同步的效果
# 也就是說，主進程和新的進程同時執行
3. 上面的示例中為什麼要有 if __name__ == "__main__"？其實這是 windows 操作系統開啟子進程的方式問題
4. 繼續深入
import time
import os
from multiprocessing import Process
def func():
time.sleep(1)
print(666, os.getpid(), os.getppid())
if __name__ == "__main__":
# 代碼執行到這里並不代表開啟了子進程
p = Process(target=func)
# 開啟了一個子進程，並執行func()
p.start()
time.sleep(1)
print(777, os.getpid(), os.getppid())
# 主進程運行的結果
777 12340 1636
# 子進程運行的結果
666 7604 12340
# 由上面兩行結果可以得出：
# 利用 os.getpid() 證明兩個進程不一樣
# 另外每次運行，os.getpid() 結果都不一樣
# 但是，12340 是主進程的 id，7604 是子進程的 id
# 1636 是 Pycharm 的 id，排列特點不變
5. 開啟多個相同的子進程示例
import time
import os
from multiprocessing import Process
def func():
time.sleep(3)
print(666, os.getpid(), os.getppid())
if __name__ == "__main__":
for i in range(10):
p = Process(target=func)
p.start()
time.sleep(1)
print(777, os.getpid(), os.getppid())
# 這里需要注意一點：Python 程序一直都是逐行執行
# 但是因為這里設置了時間延遲，因此會先執行主程序的代碼
# 運行結果：
777 29006 3833 # 暫停 2s 後再有下面的結果
666 29007 29006
666 29009 29006
666 29008 29006
666 29010 29006
666 29013 29006
666 29011 29006
666 29012 29006
666 29014 29006
666 29016 29006
666 29015 29006
# 觀察結果發現主進程只運行了一次
# 然後剩下的全是一個子進程重新運行的結果
# 主進程運行完不會結束，它會等子進程全部運行結束
# 注意變數 p 拿到的是最後一個子進程的 id
6. 開啟多個不同的子進程示例
import time
import os
from multiprocessing import Process
def func():
time.sleep(2)
print(666, os.getpid(), os.getppid())
def func2():
print(111)
if __name__ == "__main__":
for i in range(3):
p = Process(target=func)
p.start()
for i in range(2):
p = Process(target=func2)
p.start()
time.sleep(1)
print(777, os.getpid(), os.getppid())
# 運行程序時仔細觀察結果顯示順序：
111
111
777 29316 3833
666 29319 29316
666 29317 29316
666 29318 29316
7. 給子進程傳參示例
from multiprocessing import Process
def func(name):
print(666, name)
if __name__ == "__main__":
p = Process(target=func,args=(777,)) # 注意是一個元組
p.start()
import time
from multiprocessing import Process
def func(num, name):
time.sleep(1)
print(num, "hello", name)
if __name__ == "__main__":
for i in range(10):
p = Process(target=func, args=(i, "abc"))
p.start()
print("主進程")
# 運行結果：
666 777
主進程
0 hello abc
2 hello abc
1 hello abc
3 hello abc
5 hello abc
4 hello abc
6 hello abc
7 hello abc
8 hello abc
9 hello abc
# 多運行幾次，發現子進程並不是完全按順序運行的
# 比如上面先出結果 2 hello abc，再出結果 1 hello abc
8. 子進程可以有返回值嗎：不能有返回值，因為子進程函數中的返回值無法傳遞給父進程
import time
from multiprocessing import Process
def func():
time.sleep(3)
print("這是子進程,3s後才運行")
if __name__ == "__main__":
Process(target=func).start()
print("主進程")
# 運行結果：
主進程
這是子進程,3s後才運行
# 主進程會默認等待子進程結束之後才結束
# 因為父進程要負責回收子進程佔用的操作系統資源
相關資源：Python多進程寫入同一文件的方法_python多進程寫入同意文件-其它...
文章知識點與官方知識檔案匹配
Python入門技能樹首頁概覽
194693 人正在系統學習中
點擊閱讀全文
打開CSDN，閱讀體驗更佳
Python多進程(一)進程及進程池_程序員-夏天的博客
print("主進程結束") 通過上述代碼我們發現,multiprocessing.Process幫我們創建一個子進程,並且成功運行,但是我們發現,在子進程還沒執行完的時候主進程就已經死了,那麼這個子進程在主進程結束後就是一個孤兒進程,那麼我們可以讓主進程等待...
Python多進程之Process、Pool、Lock、Queue、Event、Semaphore、Pipe_大 ...
1. Python創建進程類Process python的multiprocessing模塊提供了一個創建進程的類Precess,其創建有以下兩種方法: 創建Process類的實例,並指向目標函數和傳遞參數 自定義一個類並繼承Process類,重寫__init__()和run()方法 ...
python兩個進程同時開啟只運行了一個_二十二、 深入Python的進程和線程（上篇）...
「@Author： Runsen」進程(Process)和線程(Thread)都是操作系統中的基本概念，它們之間有一些優劣和差異，那麼在Python中如何使用進程和線程？CPU計算機的核心是CPU，它承擔了計算機的所有計算任務，CPU就像一個工廠，時刻在運行著，而操作系統管理著計算機，負責任務的調度、資源的分配和管理。進程進程是指在系統中能獨立運行並作為資源分配的基本單位，它是由一組機器指令、數據...
繼續訪問
python啟動多個進程_Python多處理：只有一個進程正在運行
由於注釋表明您希望使用初始化程序和initargs參數傳遞featureVector.在Unix類型的系統上,這將導致大量的性能提升(即使selLabel中只有1個項目),因為該值將使用os.fork基本上免費傳遞給子進程.否則,每次調用foo時,featureVector都將被父進程pickle,通過管道傳遞並由子進程進行unpickled.這將花費很長時間,並且基本上將序列化所有子進程,因為它...
繼續訪問
python多進程多線程,多個程序同時運行_陳逸飛_p的博客_pyth...
python 模塊應用 開發工具 pycharm 實現方法 多任務的實現可以用進程和線程來實現 進程—> 線程---> 多任務應用 多進程操作 比如下載多個文件, 利用cpu 資源 提高效率 多任務: 同一時間執行多個任務, 比如windows操作系統 執行...
python多進程單例_Python多線程處理實例詳解【單進程/多進程】
python — 多線程處理 1、一個進程執行完後,繼續下一個進程 root@72132server:~# cd /root/python/multiprocess/ root@72132server:~/python/multiprocess# ls multprocess.py root@72132server:~/python/multiprocess# cat multprocess...
系統編程__2__父子進程的創建和回收
系統編程 這里寫的是對於小白來說更多的了解系統編程的文章，有寫的不對的地方還懇請各位大佬指出錯誤，小編一定會多多採納[手動多謝]。 那麼，上一次我們稍微了解了一下關於系統編程的一些主要內容[沒有看到的童鞋還請去上一篇文章稍微復習一下噢]。 這節課，我們先來想一想，我們為什麼要學系統編程呢？原因很簡單，我們要充分的利用CPU的性能，CPU和我們人類不太一樣，我們人類大多數情況下，在同一時間，只能完成一件事，而CPU作為無數科學家的心血當然不會這么簡單，CPU能夠同時進行多個進程，這里的進程我們可以理解成任務，
繼續訪問
android 10 system/core無法列印log問題
1.關閉重定向 system/core/init/util.cpp --- a/init/util.cpp +++ b/init/util.cpp @@ -454,7 +454,7 @@ static void InitAborter(const char* abort_message) { // SetStdioToDevNull() must be called again in second stage init. void SetStdioToDevNull(char** argv) { ...
繼續訪問
Python多進程1 一個多進程實例_BBJG_001的博客
下執行,job('主進程step1###')p1=mp.Process(target=job,args=('新進程>>>',))# 創建一個進程# 注意當只有一個參數的時候,一定要在參數後面加一個逗號,因為args需要是一個可以迭代的參量p1.start()# 開始執行新進程# p...
熱門推薦 python多進程多線程,多個程序同時運行
python 多線程 多進程同時運行 多任務要求 python 基礎語法 python 文件目錄操作 python 模塊應用 開發工具 pycharm 實現方法 多任務的實現可以用進程和線程來實現 進程—> 線程----> 多任務應用 多進程操作 比如下載多個文件, 利用cpu 資源 提高效率 多任務： 同一時間執行多個任務, 比如windows操作系統 執行方式有兩種( 表現形式 ) 並發 在單核cpu中: 在一段時間內交替執行多個任務, 例如單核cpu 處理多任務, 操作系統讓各個任務交
繼續訪問
fork()函數
多進程通信 fork()函數
繼續訪問
（1/7）Electron教程（一）什麼是 Electron，由來、適用場景 和 Electron 的環境搭建（1/7）
最近自己有個小的需求，是做一個能編輯本地特定文本的工具，需要跨平台， Windows 和 macOS，這樣，如果用原生開發的話，Windows 就要用c#macOS 就要用swift，學習成本高，並且學完用處也不是很大。我本身是前端開發的，發現了這個electron能滿足我的需求，跨平台運行，內部是 js 驅動的，簡直就是如魚得水。順便把學習的經歷寫出來，分享需要的人，我會按標題序號漸進式地編寫內容。electron。...
繼續訪問
fork()詳解
<一>： fork()函數用來創建新的進程，它的特點是調用一次返回兩次( 在原來的進程中返回新進程的 PID（新進程的 PID 肯定不等於 0）， 在新進程中返回為 0.) 函數原型：pid_t fork(void)； pid_t getpid(); 獲取當前進程的 pid 值。 pid_t getppid(); 獲取當前進程的父進程 pid 值。 圖一 如圖一所...
繼續訪問
fork()函數詳解
目錄 1.基本了解： 2.fork函數的了解： 3.僵死進程： 1.基本了解： 一個進程，包括代碼、數據和分配給進程的資源。fork 函數會新生成一個進程，調用 fork 函數的進程為父進程，新生成的進程為子進程。在父進程中返回子進程的 pid，在子進程中返回 0，失敗返回-1。 為什麼兩個進程的fpid不同呢，這與fork函數的特性有關。fork調用的一個奇妙之處就是它僅僅被調用一次，卻能夠返回兩次，它可能有三種不同的返回值： 1）在父進程中，fork返回新創建子進程的進程...
繼續訪問
Electron在Windows下的環境搭建
Electron作為一種用javascript寫桌面程序的開發方式，現在已經被大眾接受。下面就介紹如何在windows（>win7）下快速搭建Electron開發環境。 1. nodejs 的安裝 從nodejs 下載最新版本的windows安裝程序進行安裝，我下載的是v6.9.1，安裝時一路默認即可，這個安裝會把nodejs和npm配置到系統PATH中，這樣在命令行的任何位置都可以直接...
繼續訪問
python多線程pool_Python mutiprocessing多線程池pool操作示例
本文實例講述了Python mutiprocessing多線程池pool操作。分享給大家供大家參考，具體如下：python — mutiprocessing 多線程 pool腳本代碼：root@72132server:~/python/multiprocess# lsmultiprocess_pool.py multprocess.pyroot@72132server:~/python/multi...
繼續訪問
最新發布 python入門開發學習筆記之守護進程
本節重點 了解守護進程的概念 本節時長需控制在5分鍾內 一 守護進程 主進程創建子進程，然後將該進程設置成守護自己的進程，守護進程就好比崇禎皇帝身邊的老太監，崇禎皇帝已死老太監就跟著殉葬了。 關於守護進程需要強調兩點： 其一：守護進程會在主進程代碼執行結束後就終止 其二：守護進程內無法再開啟子進程,否則拋出異常：AssertionError: daemonic processes are not allowed to have children 如果我們有兩個任務需要並發執行，那麼開一個主進程和一個子進程分
繼續訪問
用python進行多進程編程時，只有主進程可以運行，子進程貌似沒有運行是什麼原因？
找了半天，原來是這個原因！這是因為multiprocessing模塊在交互模式是不支持的，在 cmd 里頭輸入 python xxx.py 來運行起來，你就可以看到子進程的執行了。
繼續訪問
linux中fork() 函數詳解
fork入門知識 一個進程，包括代碼、數據和分配給進程的資源。fork（）函數通過系統調用創建一個與原來進程幾乎完全相同的進程，也就是兩個進程可以做完全相同的事，但如果初始參數或者傳入的變數不同，兩個進程也可以做不同的事。 一個進程調用fork（）函數後，系統先給新的進程分配資源，例如存儲數據和代碼的空間。然後把原來的進程的所有值都復制到新的新進程中，只有少數值與原來的進程的值不同。相當於克隆了...
繼續訪問
Windows版 Node.js 安裝詳解以及Electron安裝
Windows Node.js 安裝詳解以及Electron安裝詳解，示例版本：node v10.15.0/npm6.4.1 介紹： 簡單的說 Node.js 就是運行在服務端的 JavaScript。 Node.js 是一個基於Chrome JavaScript 運行時建立的一個平台。 Node.js是一個事件驅動I/O服務端JavaScript環境，基於Google的V8引擎，V8引擎執...
繼續訪問
Electron 簡介
本教程我們來學習 Electron 的基礎知識，下面我們先來學習一下什麼是 Electron。 Electron是什麼 Electron 是是 GitHub 開發的一個開源框架。它允許使用 Node.js（作為後端）和 Chromium（作為前端）完成桌面 GUI 應用程序的開發。 Electron 可以用於構建具有 HTML、CSS、JavaScript 的跨平台桌面應用程序，它通過將 Chromium 和 node.js 合同一個運行的環境中來實現這一點，應用程序可以打包到 Mac、Windows 和
繼續訪問
Election的優缺點
優點 原生的介面（菜單、消息提醒、系統托盤等）。 上手難度低。能夠使用react、vue等前端框架，能方便地遷移前端組件，構建出漂亮的桌面應用。 方便熱更新 調試和測試方便 Electron使用node.js。因此，您可以導入Chrome應用程序中不容易使用的許多模塊 Electron文檔要好得多，盡管它是一個更年輕的平台 缺點 不適合開發輕量級的應用。即使一個electron的項目框架，也包含chromium內核，打包完接近200G。 相比c++開發的桌面應用，性能遠遠不如後者。 啟動速
繼續訪問
[electron]終極奧義 五千字教程丟給你
前言 本文包含打包、自動更新、簡易API、調試、進程通信等相關知識點，內容較多，可能會引起不適，請酌情查看（手動滑稽）。 electron 簡介 electron是由Github開發，是一個用Html、css、JavaScript來構建桌面應用程序的開源庫，可以打包為Mac、Windows、Linux系統下的應用。 electron是一個運行時環境，包含Node和Chromium，可以理解成把we...
繼續訪問
深入理解Java中的wait() 方法
使用場景 當某個線程獲取到鎖後，發現當前還不滿足執行的條件，就可以調用對象鎖的wait方法，進入等待狀態。 直到某個時刻，外在條件滿足了，就可以由其他線程通過調用notify()或者notifyAll()方法，來喚醒此線程。 這篇文章將側重於討論wait()方法對於線程狀態的影響，以及被喚醒後線程的狀態變更。 條件 只有已經獲取鎖的線程，才可以調用鎖的wait方法，否則會拋出異常IllegalMonitorStateException。 比如下面的代碼，A獲得了鎖後，主動調用wait方法釋放鎖和
繼續訪問
用Electron開發桌面應用的避坑指南(文末送書)
送一波高質量Web開發圖書，送5本書籍，隨你挑。抽獎規則見本文最後！抽獎規則見本文最後！抽獎規則見本文最後！如今，Electron 領域發生了重大的變革，Electron 版本更新換代極快...
繼續訪問
python多進程只有一個進程在執行
python兩個進程同時開啟只運行了一個。
F. python多進程和多線程的區別
進程是程序（軟體，應用）的一個執行實例，每個運行中的程序，可以同時創建多個進程，但至少要有一個。每個進程都提供執行程序所需的所有資源，都有一個虛擬的地址空間、可執行的代碼、操作系統的介面、安全的上下文（記錄啟動該進程的用戶和許可權等等）、唯一的進程ID、環境變數、優先順序類、最小和最大的工作空間（內存空間）。進程可以包含線程，並且每個進程必須有至少一個線程。每個進程啟動時都會最先產生一個線程，即主線程，然後主線程會再創建其他的子線程。
線程，有時被稱為輕量級進程(Lightweight Process，LWP），是程序執行流的最小單元。一個標準的線程由線程ID，當前指令指針(PC），寄存器集合和堆棧組成。另外，線程是進程中的一個實體，是被系統獨立調度和分派的基本單位，線程自己不獨立擁有系統資源，但它可與同屬一個進程的其它線程共享該進程所擁有的全部資源。每一個應用程序都至少有一個進程和一個線程。在單個程序中同時運行多個線程完成不同的被劃分成一塊一塊的工作，稱為多線程。
舉個例子，某公司要生產一種產品，於是在生產基地建設了很多廠房，每個廠房內又有多條流水生產線。所有廠房配合將整個產品生產出來，單個廠房內的流水線負責生產所屬廠房的產品部件，每個廠房都擁有自己的材料庫，廠房內的生產線共享這些材料。公司要實現生產必須擁有至少一個廠房一條生產線。換成計算機的概念，那麼這家公司就是應用程序，廠房就是應用程序的進程，生產線就是某個進程的一個線程。
線程的特點：
線程是一個execution context（執行上下文），即一個cpu執行時所需要的一串指令。假設你正在讀一本書，沒有讀完，你想休息一下，但是你想在回來時繼續先前的進度。有一個方法就是記下頁數、行數與字數這三個數值，這些數值就是execution context。如果你的室友在你休息的時候，使用相同的方法讀這本書。你和她只需要這三個數字記下來就可以在交替的時間共同閱讀這本書了。
線程的工作方式與此類似。CPU會給你一個在同一時間能夠做多個運算的幻覺，實際上它在每個運算上只花了極少的時間，本質上CPU同一時刻只能幹一件事，所謂的多線程和並發處理只是假象。CPU能這樣做是因為它有每個任務的execution context，就像你能夠和你朋友共享同一本書一樣。
進程與線程區別：
同一個進程中的線程共享同一內存空間，但進程之間的內存空間是獨立的。
同一個進程中的所有線程的數據是共享的，但進程之間的數據是獨立的。
對主線程的修改可能會影響其他線程的行為，但是父進程的修改（除了刪除以外）不會影響其他子進程。
線程是一個上下文的執行指令，而進程則是與運算相關的一簇資源。
同一個進程的線程之間可以直接通信，但是進程之間的交流需要藉助中間代理來實現。
創建新的線程很容易，但是創建新的進程需要對父進程做一次復制。
一個線程可以操作同一進程的其他線程，但是進程只能操作其子進程。
線程啟動速度快，進程啟動速度慢（但是兩者運行速度沒有可比性）。
由於現代cpu已經進入多核時代，並且主頻也相對以往大幅提升，多線程和多進程編程已經成為主流。Python全面支持多線程和多進程編程，同時還支持協程。
G. 一篇文章帶你深度解析Python線程和進程
使用Python中的線程模塊，能夠同時運行程序的不同部分，並簡化設計。如果你已經入門Python，並且想用線程來提升程序運行速度的話，希望這篇教程會對你有所幫助。
線程與進程
什麼是進程
進程是系統進行資源分配和調度的一個獨立單位 進程是具有一定獨立功能的程序關於某個數據集合上的一次運行活動,進程是系統進行資源分配和調度的一個獨立單位。每個進程都有自己的獨立內存空間，不同進程通過進程間通信來通信。由於進程比較重量，占據獨立的內存，所以上下文進程間的切換開銷（棧、寄存器、虛擬內存、文件句柄等）比較大，但相對比較穩定安全。
什麼是線程
CPU調度和分派的基本單位 線程是進程的一個實體，是CPU調度和分派的基本單位,它是比進程更小的能獨立運行的基本單位.線程自己基本上不擁有系統資源,只擁有一點在運行中必不可少的資源(如程序計數器,一組寄存器和棧),但是它可與同屬一個進程的其他的線程共享進程所擁有的全部資源。線程間通信主要通過共享內存，上下文切換很快，資源開銷較少，但相比進程不夠穩定容易丟失數據。
進程與線程的關系圖
線程與進程的區別：
進程
現實生活中，有很多的場景中的事情是同時進行的，比如開車的時候 手和腳共同來駕駛 汽車 ，比如唱歌跳舞也是同時進行的，再比如邊吃飯邊打電話；試想如果我們吃飯的時候有一個領導來電，我們肯定是立刻就接聽了。但是如果你吃完飯再接聽或者回電話，很可能會被開除。
注意：
多任務的概念
什麼叫 多任務 呢？簡單地說，就是操作系統可以同時運行多個任務。打個比方，你一邊在用瀏覽器上網，一邊在聽MP3，一邊在用Word趕作業，這就是多任務，至少同時有3個任務正在運行。還有很多任務悄悄地在後台同時運行著，只是桌面上沒有顯示而已。
現在，多核CPU已經非常普及了，但是，即使過去的單核CPU，也可以執行多任務。由於CPU執行代碼都是順序執行的，那麼，單核CPU是怎麼執行多任務的呢？
答案就是操作系統輪流讓各個任務交替執行，任務1執行0.01秒，切換到任務2，任務2執行0.01秒，再切換到任務3，執行0.01秒，這樣反復執行下去。表面上看，每個任務都是交替執行的，但是，由於CPU的執行速度實在是太快了，我們感覺就像所有任務都在同時執行一樣。
真正的並行執行多任務只能在多核CPU上實現，但是，由於任務數量遠遠多於CPU的核心數量，所以，操作系統也會自動把很多任務輪流調度到每個核心上執行。 其實就是CPU執行速度太快啦！以至於我們感受不到在輪流調度。
並行與並發
並行（Parallelism）
並行：指兩個或兩個以上事件（或線程）在同一時刻發生，是真正意義上的不同事件或線程在同一時刻，在不同CPU資源呢上（多核），同時執行。
特點
並發（Concurrency）
指一個物理CPU(也可以多個物理CPU) 在若幹道程序（或線程）之間多路復用，並發性是對有限物理資源強制行使多用戶共享以提高效率。
特點
multiprocess.Process模塊
process模塊是一個創建進程的模塊，藉助這個模塊，就可以完成進程的創建。
語法：Process([group [, target [, name [, args [, kwargs]]]]])
由該類實例化得到的對象，表示一個子進程中的任務（尚未啟動）。
注意：1. 必須使用關鍵字方式來指定參數；2. args指定的為傳給target函數的位置參數，是一個元祖形式，必須有逗號。
參數介紹：
group：參數未使用，默認值為None。
target：表示調用對象，即子進程要執行的任務。
args：表示調用的位置參數元祖。
kwargs：表示調用對象的字典。如kwargs = {'name':Jack, 'age':18}。
name：子進程名稱。
代碼：
除了上面這些開啟進程的方法之外，還有一種以繼承Process的方式開啟進程的方式：
通過上面的研究，我們千方百計實現了程序的非同步，讓多個任務可以同時在幾個進程中並發處理，他們之間的運行沒有順序，一旦開啟也不受我們控制。盡管並發編程讓我們能更加充分的利用IO資源，但是也給我們帶來了新的問題。
當多個進程使用同一份數據資源的時候，就會引發數據安全或順序混亂問題，我們可以考慮加鎖，我們以模擬搶票為例，來看看數據安全的重要性。
加鎖可以保證多個進程修改同一塊數據時，同一時間只能有一個任務可以進行修改，即串列的修改。加鎖犧牲了速度，但是卻保證了數據的安全。
因此我們最好找尋一種解決方案能夠兼顧：1、效率高（多個進程共享一塊內存的數據）2、幫我們處理好鎖問題。
mutiprocessing模塊為我們提供的基於消息的IPC通信機制：隊列和管道。隊列和管道都是將數據存放於內存中 隊列又是基於（管道+鎖）實現的，可以讓我們從復雜的鎖問題中解脫出來， 我們應該盡量避免使用共享數據，盡可能使用消息傳遞和隊列，避免處理復雜的同步和鎖問題，而且在進程數目增多時，往往可以獲得更好的可獲展性（ 後續擴展該內容 ）。
線程
Python的threading模塊
Python 供了幾個用於多線程編程的模塊，包括 thread, threading 和 Queue 等。thread 和 threading 模塊允許程序員創建和管理線程。thread 模塊 供了基本的線程和鎖的支持，而 threading 供了更高級別，功能更強的線程管理的功能。Queue 模塊允許用戶創建一個可以用於多個線程之間 共享數據的隊列數據結構。
python創建和執行線程
創建線程代碼
1. 創建方法一:
2. 創建方法二:
進程和線程都是實現多任務的一種方式，例如：在同一台計算機上能同時運行多個QQ（進程),一個QQ可以打開多個聊天窗口（線程）。資源共享：進程不能共享資源，而線程共享所在進程的地址空間和其他資源，同時，線程有自己的棧和棧指針。所以在一個進程內的所有線程共享全局變數，但多線程對全局變數的更改會導致變數值得混亂。
代碼演示:
得到的結果是：
首先需要明確的一點是GIL並不是Python的特性，它是在實現Python解析器(CPython)時所引入的一個概念。就好比C++是一套語言（語法）標准，但是可以用不同的編譯器來編譯成可執行代碼。同樣一段代碼可以通過CPython，PyPy，Psyco等不同的Python執行環境來執行（其中的JPython就沒有GIL）。
那麼CPython實現中的GIL又是什麼呢？GIL全稱Global Interpreter Lock為了避免誤導，我們還是來看一下官方給出的解釋：
主要意思為:
因此，解釋器實際上被一個全局解釋器鎖保護著，它確保任何時候都只有一個Python線程執行。在多線程環境中，Python 虛擬機按以下方式執行:
由於GIL的存在，Python的多線程不能稱之為嚴格的多線程。因為 多線程下每個線程在執行的過程中都需要先獲取GIL，保證同一時刻只有一個線程在運行。
由於GIL的存在，即使是多線程，事實上同一時刻只能保證一個線程在運行， 既然這樣多線程的運行效率不就和單線程一樣了嗎，那為什麼還要使用多線程呢？
由於以前的電腦基本都是單核CPU，多線程和單線程幾乎看不出差別，可是由於計算機的迅速發展，現在的電腦幾乎都是多核CPU了，最少也是兩個核心數的，這時差別就出來了：通過之前的案例我們已經知道，即使在多核CPU中，多線程同一時刻也只有一個線程在運行，這樣不僅不能利用多核CPU的優勢，反而由於每個線程在多個CPU上是交替執行的，導致在不同CPU上切換時造成資源的浪費，反而會更慢。即原因是一個進程只存在一把gil鎖，當在執行多個線程時，內部會爭搶gil鎖，這會造成當某一個線程沒有搶到鎖的時候會讓cpu等待，進而不能合理利用多核cpu資源。
但是在使用多線程抓取網頁內容時，遇到IO阻塞時，正在執行的線程會暫時釋放GIL鎖，這時其它線程會利用這個空隙時間，執行自己的代碼，因此多線程抓取比單線程抓取性能要好，所以我們還是要使用多線程的。
GIL對多線程Python程序的影響
程序的性能受到計算密集型(CPU)的程序限制和I/O密集型的程序限制影響,那什麼是計算密集型和I/O密集型程序呢?
計算密集型：要進行大量的數值計算，例如進行上億的數字計算、計算圓周率、對視頻進行高清解碼等等。這種計算密集型任務雖然也可以用多任務完成，但是花費的主要時間在任務切換的時間，此時CPU執行任務的效率比較低。
IO密集型：涉及到網路請求(time.sleep())、磁碟IO的任務都是IO密集型任務，這類任務的特點是CPU消耗很少，任務的大部分時間都在等待IO操作完成（因為IO的速度遠遠低於CPU和內存的速度）。對於IO密集型任務，任務越多，CPU效率越高，但也有一個限度。
當然為了避免GIL對我們程序產生影響，我們也可以使用，線程鎖。
Lock&RLock
常用的資源共享鎖機制：有Lock、RLock、Semphore、Condition等，簡單給大家分享下Lock和RLock。
Lock
特點就是執行速度慢，但是保證了數據的安全性
RLock
使用鎖代碼操作不當就會產生死鎖的情況。
什麼是死鎖
死鎖：當線程A持有獨占鎖a，並嘗試去獲取獨占鎖b的同時，線程B持有獨占鎖b，並嘗試獲取獨占鎖a的情況下，就會發生AB兩個線程由於互相持有對方需要的鎖，而發生的阻塞現象，我們稱為死鎖。即死鎖是指多個進程因競爭資源而造成的一種僵局，若無外力作用，這些進程都將無法向前推進。
所以，在系統設計、進程調度等方面注意如何不讓這四個必要條件成立，如何確定資源的合理分配演算法，避免進程永久占據系統資源。
死鎖代碼
python線程間通信
如果各個線程之間各干各的，確實不需要通信，這樣的代碼也十分的簡單。但這一般是不可能的，至少線程要和主線程進行通信，不然計算結果等內容無法取回。而實際情況中要復雜的多，多個線程間需要交換數據，才能得到正確的執行結果。
python中Queue是消息隊列，提供線程間通信機制，python3中重名為為queue，queue模塊塊下提供了幾個阻塞隊列，這些隊列主要用於實現線程通信。
在 queue 模塊下主要提供了三個類，分別代表三種隊列，它們的主要區別就在於進隊列、出隊列的不同。
簡單代碼演示
此時代碼會阻塞，因為queue中內容已滿，此時可以在第四個queue.put('蘋果')後面添加timeout，則成為 queue.put('蘋果'，timeout=1)如果等待1秒鍾仍然是滿的就會拋出異常，可以捕獲異常。
同理如果隊列是空的，無法獲取到內容默認也會阻塞，如果不阻塞可以使用queue.get_nowait()。
在掌握了 Queue 阻塞隊列的特性之後，在下面程序中就可以利用 Queue 來實現線程通信了。
下面演示一個生產者和一個消費者，當然都可以多個
使用queue模塊，可在線程間進行通信，並保證了線程安全。
協程
協程，又稱微線程，纖程。英文名Coroutine。
協程是python個中另外一種實現多任務的方式，只不過比線程更小佔用更小執行單元（理解為需要的資源）。為啥說它是一個執行單元，因為它自帶CPU上下文。這樣只要在合適的時機， 我們可以把一個協程 切換到另一個協程。只要這個過程中保存或恢復 CPU上下文那麼程序還是可以運行的。
通俗的理解：在一個線程中的某個函數，可以在任何地方保存當前函數的一些臨時變數等信息，然後切換到另外一個函數中執行，注意不是通過調用函數的方式做到的，並且切換的次數以及什麼時候再切換到原來的函數都由開發者自己確定。
在實現多任務時，線程切換從系統層面遠不止保存和恢復 CPU上下文這么簡單。操作系統為了程序運行的高效性每個線程都有自己緩存Cache等等數據，操作系統還會幫你做這些數據的恢復操作。所以線程的切換非常耗性能。但是協程的切換只是單純的操作CPU的上下文，所以一秒鍾切換個上百萬次系統都抗的住。
greenlet與gevent
為了更好使用協程來完成多任務，除了使用原生的yield完成模擬協程的工作，其實python還有的greenlet模塊和gevent模塊，使實現協程變的更加簡單高效。
greenlet雖說實現了協程，但需要我們手工切換，太麻煩了，gevent是比greenlet更強大的並且能夠自動切換任務的模塊。
其原理是當一個greenlet遇到IO(指的是input output 輸入輸出，比如網路、文件操作等)操作時，比如訪問網路，就自動切換到其他的greenlet，等到IO操作完成，再在適當的時候切換回來繼續執行。
模擬耗時操作：
如果有耗時操作也可以換成，gevent中自己實現的模塊，這時候就需要打補丁了。
使用協程完成一個簡單的二手房信息的爬蟲代碼吧！
以下文章來源於Python專欄 ，作者宋宋
文章鏈接：https://mp.weixin.qq.com/s/2r3_ipU3HjdA5VnqSHjUnQ
H. Python 相比 Java的優勢是什麼缺點又是什麼
優點：簡單易學；缺點：速度比較慢。