python進程同步

發布時間: 2022-12-18 04:35:51

① python中的進程-實戰部分

如果想了解進程可以先看一下這一篇 python中的進程-理論部分

python中的多線程無法利用多核優勢，如果想要充分地使用多核CPU的資源（os.cpu_count()查看），在python中大部分情況需要使用多進程。Python提供了multiprocessing。
multiprocessing模塊用來開啟子進程，並在子進程中執行我們定製的任務（比如函數），該模塊與多線程模塊threading的編程介面類似。

multiprocessing模塊的功能眾多：支持子進程、通信和共享數據、執行不同形式的同步，提供了Process、Queue、Pipe、Lock等組件。

需要再次強調的一點是：與線程不同，進程沒有任何共享狀態，進程修改的數據，改動僅限於該進程內。

創建進程的類 ：

參數介紹：

group參數未使用，值始終為None

target表示調用對象，即子進程要執行的任務

args表示調用對象的位置參數元組，args=(1,2,'tiga',)

kwargs表示調用對象的字典,kwargs={'name':'tiga','age':18}

name為子進程的名稱

方法介紹：

p.start()：啟動進程，並調用該子進程中的p.run()
p.run():進程啟動時運行的方法，正是它去調用target指定的函數，我們自定義類的類中一定要實現該方法

p.terminate():強制終止進程p，不會進行任何清理操作，如果p創建了子進程，該子進程就成了僵屍進程，使用該方法需要特別小心這種情況。如果p還保存了一個鎖那麼也將不會被釋放，進而導致死鎖
p.is_alive():如果p仍然運行，返回True

p.join([timeout]):主線程等待p終止（強調：是主線程處於等的狀態，而p是處於運行的狀態）。timeout是可選的超時時間，需要強調的是，p.join只能join住start開啟的進程，而不能join住run開啟的進程

屬性介紹：

注意：在windows中Process()必須放到# if __name__ == '__main__':下

創建並開啟子進程的兩種方式

方法一:

方法二：

有了join，程序不就是串列了嗎？？？

terminate與is_alive

name與pid

② python進程間通信怎麼理解

在2.6才開始使用
multiprocessing 是一個使用方法類似threading模塊的進程模塊。允許程序員做並行開發。並且可以在UNIX和Windows下運行。
通過創建一個Process 類型並且通過調用call()方法spawn一個進程。

一個比較簡單的例子：
#!/usr/bin/env python

from multiprocessing import Process
import time
def f(name):
time.sleep(1)
print 'hello ',name
print os.getppid() #取得父進程ID
print os.getpid() #取得進程ID
process_list = []
if __name__ == '__main__':
for i in range(10):
p = Process(target=f,args=(i,))
p.start()
process_list.append(p)
for j in process_list:
j.join()

進程間通信：
有兩種主要的方式：Queue、Pipe
1- Queue類幾乎就是Queue.Queue的復制，示例：
#!/usr/bin/env python

from multiprocessing import Process,Queue
import time
def f(name):
time.sleep(1)
q.put(['hello'+str(name)])
process_list = []
q = Queue()
if __name__ == '__main__':
for i in range(10):
p = Process(target=f,args=(i,))
p.start()
process_list.append(p)
for j in process_list:
j.join()
for i in range(10):
print q.get()
2- Pipe 管道
#!/usr/bin/env python

from multiprocessing import Process,Pipe
import time
import os

def f(conn,name):
time.sleep(1)
conn.send(['hello'+str(name)])
print os.getppid(),'-----------',os.getpid()
process_list = []
parent_conn,child_conn = Pipe()
if __name__ == '__main__':
for i in range(10):
p = Process(target=f,args=(child_conn,i))
p.start()
process_list.append(p)
for j in process_list:
j.join()
for p in range(10):
print parent_conn.recv()
Pipe()返回兩個連接類，代表兩個方向。如果兩個進程在管道的兩邊同時讀或同時寫，會有可能造成corruption.

進程間同步
multiprocessing contains equivalents of all the synchronization primitives from threading.
例如，可以加一個鎖，以使某一時刻只有一個進程print
#!/usr/bin/env python

from multiprocessing import Process,Lock
import time
import os

def f(name):
lock.acquire()
time.sleep(1)
print 'hello--'+str(name)
print os.getppid(),'-----------',os.getpid()
lock.release()
process_list = []
lock = Lock()
if __name__ == '__main__':
for i in range(10):
p = Process(target=f,args=(i,))
p.start()
process_list.append(p)
for j in process_list:
j.join()

進程間共享狀態 Sharing state between processes
當然盡最大可能防止使用共享狀態，但最終有可能會使用到.
1-共享內存
可以通過使用Value或者Array把數據存儲在一個共享的內存表中
#!/usr/bin/env python

from multiprocessing import Process,Value,Array
import time
import os

def f(n,a,name):
time.sleep(1)
n.value = name * name
for i in range(len(a)):
a[i] = -i
process_list = []
if __name__ == '__main__':
num = Value('d',0.0)
arr = Array('i',range(10))
for i in range(10):
p = Process(target=f,args=(num,arr,i))
p.start()
process_list.append(p)
for j in process_list:
j.join()
print num.value
print arr[:]
輸出：
jimin@Jimin:~/projects$ python pp.py
81.0
[0, -1, -2, -3, -4, -5, -6, -7, -8, -9]
'd'和'i'參數是num和arr用來設置類型，d表示一個雙精浮點類型，i表示一個帶符號的整型。
更加靈活的共享內存可以使用multiprocessing.sharectypes模塊

Server process
Manager()返回一個manager類型，控制一個server process，可以允許其它進程通過代理復制一些python objects
支持list,dict,Namespace,Lock,Semaphore,BoundedSemaphore,Condition,Event,Queue,Value,Array
例如：
#!/usr/bin/env python

from multiprocessing import Process,Manager
import time
import os

def f(d,name):
time.sleep(1)
d[name] = name * name
print d
process_list = []
if __name__ == '__main__':
manager = Manager()
d = manager.dict()
for i in range(10):
p = Process(target=f,args=(d,i))
p.start()
process_list.append(p)
for j in process_list:
j.join()
print d
輸出結果：
{2: 4}
{2: 4, 3: 9}
{2: 4, 3: 9, 4: 16}
{1: 1, 2: 4, 3: 9, 4: 16}
{1: 1, 2: 4, 3: 9, 4: 16, 5: 25}
{0: 0, 1: 1, 2: 4, 3: 9, 4: 16, 5: 25}
{0: 0, 1: 1, 2: 4, 3: 9, 4: 16, 5: 25, 6: 36}
{0: 0, 1: 1, 2: 4, 3: 9, 4: 16, 5: 25, 6: 36, 8: 64}
{0: 0, 1: 1, 2: 4, 3: 9, 4: 16, 5: 25, 6: 36, 7: 49, 8: 64}
{0: 0, 1: 1, 2: 4, 3: 9, 4: 16, 5: 25, 6: 36, 7: 49, 8: 64, 9: 81}
{0: 0, 1: 1, 2: 4, 3: 9, 4: 16, 5: 25, 6: 36, 7: 49, 8: 64, 9: 81}
Server process managers比共享內存方法更加的靈活，一個單獨的manager可以被同一網路的不同計算機的多個進程共享。
比共享內存更加的緩慢

使用工作池Using a pool of workers
Pool類代表 a pool of worker processes.
It has methods which allows tasks to be offloaded to the worker processes in a few different ways.

③ 簡述python進程，線程和協程的區別

協程多與線程進行比較
1) 一個線程可以多個協程，一個進程也可以單獨擁有多個協程，這樣python中則能使用多核CPU。
2) 線程進程都是同步機制，而協程則是非同步
3) 協程能保留上一次調用時的狀態，每次過程重入時，就相當於進入上一次調用的狀態

④ Python入門系列（十二）——GUI+多進程

話說，python做圖形界面並不明智，效率並不高。但在某些特殊需求下還是需要我們去使用，所以python擁有多個第三方庫用以實現GUI，本章我們使用python基本模塊tkinter進行學習，因為需求並不大，所以不做太多拓展。
繼續改寫上一章的IP查詢系統（= =，要玩爛了），首先略改下IpWhere.py以備調用~

然後使用tkinter模塊進行圖形界面的實現，調用預編譯的IpWhere模塊：

額，太丑了，但基本實現我們小小的需求，在以後的py學習中，我們再涉及其他的第三方模塊，此處就當是入門了解吧。

十分抱歉把這么重要的內容放在最後，要不是大佬指點，此次學習可能就要錯過多進程的問題了。
Unix系統提供了forx，python可藉助os模塊調用，從而實現多進程，然而windows系統並不具備，所以我們選擇python內置的multiprocessing多進程模塊進行學習。

首先我們藉助直接調用多進程來改寫下我們在多線程章節用到的例子！

顯然，這么寫實在太蠢了，如果我們的任務量巨大，這並不合適。所以我們引入了進程池的概念，使用進程池進行改寫：

在此，我們可以看到所有進程是並發執行的，同樣，我們在多線程章節就講過，主進程的結束意味著程序退出，所以我們需要藉助join()方法堵塞進程。

我們知道線程共享內存空間，而進程的內存是獨立的，同一個進程的線程之間可以直接交流，也就帶來了線程同步的苦惱，這個我們在多線程章節已經講過了；而兩個進程想通信，則必須通過一個中間代理來實現，即我們接下來的內容：進程間通信。

進程之間肯定是需要通信的，操作系統提供了很多機制來實現進程間的通信。Python的multiprocessing模塊包裝了底層的機制，提供了Queue、Pipes等多種方式來交換數據。我們接下來就以Queue的方式進行學習。

Queue.Queue是進程內非阻塞隊列，multiprocess.Queue是跨進程通信隊列，前者是各自私有，後者是各子進程共有。

還有一個在後者基礎上進行封裝的multiprocess.Manager.Queue()方法，如果要使用Pool創建進程，就需要使用multiprocessing.Manager()中的Queue()，而不是multiprocessing.Queue()，否則會得到一條如下的錯誤信息： RuntimeError: Queue objects should only be shared between processes through inheritance.

接下來我們就藉助進程池來進行多進程操作的改寫，感謝大佬一路輔導。

我們可以看到兩個子線程先執行，然後一個子線程單獨執行，此處有意而為之，讓大家更清晰的了解隊列的使用。期間有一處我們放棄使用jion()方法堵塞，而是自己寫了個循環堵塞，大家根據自己習慣來就好。

話說，真的沒人吐槽么？上面的例子從需求上來講，完全就不需要多線程好不好！emmmm，我們來點實力拓展，寫一個有智商的多線程腳本，順便結合上一節的web來一個綜合篇，隨便找個現實需求吧！

emmm，比如我們來到當當網買書，搜一下我們想要的書籍，發現！！太多了！！真J2亂！！看不過來！！不想翻頁！！直接告訴我哪個便宜、哪個牛逼好不好！！

簡單看下這個url：
http://search.dangdang.com/?key=滲透測試&ddsale=1&page_index=2
其中ddsale參數代表當當自營，page_index代表頁數，key代表搜索內容，我們本次的變數只有頁數。

所以我們構造請求的url為:
'http://search.dangdang.com/?key=滲透測試&ddsale=1&page_index='+str(page)
如果修改的內容不使用str字元串轉化，會收到如下報錯：
TypeError: can only concatenate str (not "int") to str
然後我們看一下頁面內容的分布情況，本次我們關心賣什麼書，賣多少錢？

對應的編寫我們的正則匹配規則，當然了，有更簡便的第三方庫可以幫我們處理，但為了更好的形成流程性認識，我們這里依然使用正則。
我們對應我們需要的書籍名稱和當前價格匹配如下：
<a title=" (.*?)" ddclick=
<span class="search_now_price">¥(.*?)</span>
那麼，思路理清了，我們就開始使用多線程來寫我們的小系統~

然後我們去查看一下我們的結果文件~

現在這個小系統具備的功能就是根據用戶需要選擇要檢索的書籍，然後整理下名稱和價格，開了10個線程，如果小夥伴pc給力的話可以繼續加。簡單的異常處理機制和界面交互，基本滿足日常所需。

⑤ python 多進程

基於官方文檔：
https://docs.python.org/zh-cn/3/library/multiprocessing.html
日樂購，剛才看到的一個博客，寫的都不太對，還是基於官方的比較穩妥
我就是喜歡抄官方的，哈哈

通常我們使用Process實例化一個進程，並調用他的 start() 方法啟動它。
這種方法和 Thread 是一樣的。

上圖中，我寫了 p.join() 所以主進程是等待子進程執行完後，才執行 print("運行結束")
否則就是反過來了（這個不一定，看你的語句了，順序其實是隨機的）例如：

主進加個 sleep

所以不加join() ,其實子進程和主進程是各干各的，誰也不等誰。都執行完後，文件運行就結束了

上面我們用了 os.getpid() 和 os.getppid() 獲取當前進程，和父進程的id
下面就講一下，這兩個函數的用法：
os.getpid()
返回當前進程的id
os.getppid()
返回父進程的id。父進程退出後，unix 返回初始化進程（1）中的一個
windows返回相同的id (可能被其他進程使用了)
這也就解釋了，為啥我上面的程序運行多次，第一次列印的parentid 都是 14212 了。
而子進程的父級 process id 是調用他的那個進程的 id ： 1940

視頻筆記：
多進程：使用大致方法：

參考：進程通信（pipe和queue）

pool.map （函數可以有return 也可以共享內存或queue）結果直接是個列表

poll.apply_async() （同map,只不過是一個進程，返回結果用 xx.get() 獲得）

報錯：

參考： https://blog.csdn.net/xiemanR/article/details/71700531

把 pool = Pool() 放到 if name == " main ": 下面初始化搞定。
結果：

這個肯定有解釋的

測試多進程計算效果：
進程池運行：

結果：

普通計算：

我們同樣傳入 1 2 10 三個參數測試：

其實對比下來開始快了一半的；
我們把循環里的數字去掉一個 0；
單進程：

多進程：

兩次測試單進程/進程池分別為 0.669 和 0.772 幾乎成正比的。
問題二：
視圖：
post 視圖裡面

Music 類：

直接報錯：

寫在類裡面也在函數里用 self.pool 調用也不行，也是相同的錯誤。

最後把 pool = Pool 直接寫在 search 函數裡面，奇跡出現了：

前台也能顯示搜索的音樂結果了

總結一點，進程這個東西，最好寫在直接運行的函數裡面，而不是一個函數跳來跳去。因為最後可能是在子進程的子進程運行的，這是不許的，會報錯。
還有一點，多進程運行的函數對象，不能是 lambda 函數。也許lambda 虛擬，在內存？？

使用 pool.map 子進程函數報錯，導致整個 pool 掛了:
參考： https://blog.csdn.net/hedongho/article/details/79139606
主要你要，對函數內部捕獲錯誤，而不能讓異常拋出就可以了。

關於map 傳多個函數參數
我一開始，就是正常思維，多個參數，搞個元祖，讓參數一一對應不就行了：

報錯：

參考：
https://blog.csdn.net/qq_15969343/article/details/84672527
普通的 process 當讓可以穿多個參數，map 卻不知道咋傳的。
apply_async 和map 一樣，不知道咋傳的。

最簡單的方法：
使用 starmap 而不是 map

結果：
子進程結束
1.8399453163146973
成功拿到結果了

關於map 和 starmap 不同的地方看源碼：

關於apply_async() ,我沒找到多參數的方法，大不了用一個迭代的 starmap 實現。哈哈

關於上面源碼裡面有 itertools.starmap
itertools 用法參考：
https://docs.python.org/zh-cn/3/library/itertools.html#itertool-functions

有個問題，多進程最好不要使用全部的 cpu , 因為這樣可能影響其他任務，所以在進程池添加 process 參數指定，cpu 個數：

上面就是預留了一個cpu 干其他事的

後面直接使用 Queue 遇到這個問題：

解決：
Manager().Queue() 代替 Queue()

因為 queue.get() 是堵塞型的，所以可以提前判斷是不是空的，以免堵塞進程。比如下面這樣：
使用 queue.empty() 空為True

⑥ python多線程怎樣同步

鎖機制
�6�9�6�9threading的Lock類，用該類的acquire函數進行加鎖，用realease函數進行解鎖

import threading
import time

class Num:
def __init__(self):
self.num = 0
self.lock = threading.Lock()
def add(self):
self.lock.acquire()#加鎖，鎖住相應的資源
self.num += 1
num = self.num
self.lock.release()#解鎖，離開該資源
return num

n = Num()
class jdThread(threading.Thread):
def __init__(self,item):
threading.Thread.__init__(self)
self.item = item
def run(self):
time.sleep(2)
value = n.add()#將num加1，並輸出原來的數據和+1之後的數據
print(self.item,value)

for item in range(5):
t = jdThread(item)
t.start()
t.join()#使線程一個一個執行
�6�9�6�9當一個線程調用鎖的acquire()方法獲得鎖時，鎖就進入「locked」狀態。每次只有一個線程可以獲得鎖。如果此時另一個線程試圖獲得這個鎖，該線程就會變為「blocked」狀態，稱為「同步阻塞」（參見多線程的基本概念）。
�6�9�6�9直到擁有鎖的線程調用鎖的release()方法釋放鎖之後，鎖進入「unlocked」狀態。線程調度程序從處於同步阻塞狀態的線程中選擇一個來獲得鎖，並使得該線程進入運行（running）狀態。

信號量
�6�9�6�9信號量也提供acquire方法和release方法，每當調用acquire方法的時候，如果內部計數器大於0，則將其減1，如果內部計數器等於0，則會阻塞該線程，知道有線程調用了release方法將內部計數器更新到大於1位置。

import threading
import time
class Num:
def __init__(self):
self.num = 0
self.sem = threading.Semaphore(value = 3)
#允許最多三個線程同時訪問資源

def add(self):
self.sem.acquire()#內部計數器減1
self.num += 1
num = self.num
self.sem.release()#內部計數器加1
return num

n = Num()
class jdThread(threading.Thread):
def __init__(self,item):
threading.Thread.__init__(self)
self.item = item
def run(self):
time.sleep(2)
value = n.add()
print(self.item,value)

for item in range(100):
t = jdThread(item)
t.start()
t.join()
條件判斷
�6�9�6�9所謂條件變數，即這種機制是在滿足了特定的條件後，線程才可以訪問相關的數據。
�6�9�6�9它使用Condition類來完成，由於它也可以像鎖機制那樣用，所以它也有acquire方法和release方法，而且它還有wait，notify，notifyAll方法。

"""
一個簡單的生產消費者模型，通過條件變數的控制產品數量的增減，調用一次生產者產品就是+1，調用一次消費者產品就會-1.
"""

"""
使用 Condition 類來完成，由於它也可以像鎖機制那樣用，所以它也有 acquire 方法和 release 方法，而且它還有
wait， notify， notifyAll 方法。
"""

import threading
import queue,time,random

class Goods:#產品類
def __init__(self):
self.count = 0
def add(self,num = 1):
self.count += num
def sub(self):
if self.count>=0:
self.count -= 1
def empty(self):
return self.count <= 0

class Procer(threading.Thread):#生產者類
def __init__(self,condition,goods,sleeptime = 1):#sleeptime=1
threading.Thread.__init__(self)
self.cond = condition
self.goods = goods
self.sleeptime = sleeptime
def run(self):
cond = self.cond
goods = self.goods
while True:
cond.acquire()#鎖住資源
goods.add()
print("產品數量:",goods.count,"生產者線程")
cond.notifyAll()#喚醒所有等待的線程--》其實就是喚醒消費者進程
cond.release()#解鎖資源
time.sleep(self.sleeptime)

class Consumer(threading.Thread):#消費者類
def __init__(self,condition,goods,sleeptime = 2):#sleeptime=2
threading.Thread.__init__(self)
self.cond = condition
self.goods = goods
self.sleeptime = sleeptime
def run(self):
cond = self.cond
goods = self.goods
while True:
time.sleep(self.sleeptime)
cond.acquire()#鎖住資源
while goods.empty():#如無產品則讓線程等待
cond.wait()
goods.sub()
print("產品數量:",goods.count,"消費者線程")
cond.release()#解鎖資源

g = Goods()
c = threading.Condition()

pro = Procer(c,g)
pro.start()

con = Consumer(c,g)
con.start()
同步隊列
�6�9�6�9put方法和task_done方法，queue有一個未完成任務數量num，put依次num+1，task依次num-1.任務都完成時任務結束。

import threading
import queue
import time
import random

'''
1.創建一個 Queue.Queue() 的實例，然後使用數據對它進行填充。
2.將經過填充數據的實例傳遞給線程類，後者是通過繼承 threading.Thread 的方式創建的。
3.每次從隊列中取出一個項目，並使用該線程中的數據和 run 方法以執行相應的工作。
4.在完成這項工作之後，使用 queue.task_done() 函數向任務已經完成的隊列發送一個信號。
5.對隊列執行 join 操作，實際上意味著等到隊列為空，再退出主程序。
'''

class jdThread(threading.Thread):
def __init__(self,index,queue):
threading.Thread.__init__(self)
self.index = index
self.queue = queue

def run(self):
while True:
time.sleep(1)
item = self.queue.get()
if item is None:
break
print("序號：",self.index,"任務",item,"完成")
self.queue.task_done()#task_done方法使得未完成的任務數量-1

q = queue.Queue(0)
'''
初始化函數接受一個數字來作為該隊列的容量，如果傳遞的是
一個小於等於0的數，那麼默認會認為該隊列的容量是無限的.
'''
for i in range(2):
jdThread(i,q).start()#兩個線程同時完成任務

for i in range(10):
q.put(i)#put方法使得未完成的任務數量+1

⑦ 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兩個進程同時開啟只運行了一個。

⑧ python可以多進程嗎

想要充分利用多核CPU資源，Python中大部分情況下都需要使用多進程，Python中提供了multiprocessing這個包實現多進程。multiprocessing支持子進程、進程間的同步與通信，提供了Process、Queue、Pipe、Lock等組件。

開辟子進程
multiprocessing中提供了Process類來生成進程實例

Process([group [, target [, name [, args [, kwargs]]]]])
group分組，實際上不使用
target表示調用對象，你可以傳入方法的名字
args表示給調用對象以元組的形式提供參數，比如target是函數a，他有兩個參數m，n，那麼該參數為args=(m, n)即可
kwargs表示調用對象的字典
name是別名，相當於給這個進程取一個名字
先來個小例子：

# -*- coding:utf-8 -*-
from multiprocessing import Process, Pool
import os
import time

def run_proc(wTime):
n = 0
while n < 3:
print "subProcess %s run," % os.getpid(), "{0}".format(time.ctime()) #獲取當前進程號和正在運行是的時間
time.sleep(wTime) #等待（休眠）
n += 1

if __name__ == "__main__":
p = Process(target=run_proc, args=(2,)) #申請子進程
p.start() #運行進程
print "Parent process run. subProcess is ", p.pid
print "Parent process end,{0}".format(time.ctime())
運行結果：

Parent process run. subProcess is 30196
Parent process end,Mon Mar 27 11:20:21 2017
subProcess 30196 run, Mon Mar 27 11:20:21 2017
subProcess 30196 run, Mon Mar 27 11:20:23 2017
subProcess 30196 run, Mon Mar 27 11:20:25 2017

根據運行結果可知，父進程運行結束後子進程仍然還在運行，這可能造成僵屍（ zombie）進程。

通常情況下，當子進程終結時，它會通知父進程，清空自己所佔據的內存，並在內核里留下自己的退出信息。父進程在得知子進程終結時，會從內核中取出子進程的退出信息。但是，如果父進程早於子進程終結，這可能造成子進程的退出信息滯留在內核中，子進程成為僵屍（zombie）進程。當大量僵屍進程積累時，內存空間會被擠占。

有什麼辦法可以避免僵屍進程呢？
這里介紹進程的一個屬性 deamon，當其值為TRUE時，其父進程結束，該進程也直接終止運行（即使還沒運行完）。
所以給上面的程序加上p.deamon = true，看看效果。

# -*- coding:utf-8 -*-
from multiprocessing import Process, Pool
import os
import time

def run_proc(wTime):
n = 0
while n < 3:
print "subProcess %s run," % os.getpid(), "{0}".format(time.ctime())
time.sleep(wTime)
n += 1

if __name__ == "__main__":
p = Process(target=run_proc, args=(2,))
p.daemon = True #加入daemon
p.start()
print "Parent process run. subProcess is ", p.pid
print "Parent process end,{0}".format(time.ctime())
執行結果：

Parent process run. subProcess is 31856
Parent process end,Mon Mar 27 11:40:10 2017

這是問題又來了，子進程並沒有執行完，這不是所期望的結果。有沒辦法將子進程執行完後才讓父進程結束呢？
這里引入p.join()方法，它使子進程執行結束後，父進程才執行之後的代碼

# -*- coding:utf-8 -*-
from multiprocessing import Process, Pool
import os
import time

def run_proc(wTime):
n = 0
while n < 3:
print "subProcess %s run," % os.getpid(), "{0}".format(time.ctime())
time.sleep(wTime)
n += 1

if __name__ == "__main__":
p = Process(target=run_proc, args=(2,))
p.daemon = True
p.start()
p.join() #加入join方法
print "Parent process run. subProcess is ", p.pid
print "Parent process end,{0}".format(time.ctime())
執行結果：

subProcess 32076 run, Mon Mar 27 11:46:07 2017
subProcess 32076 run, Mon Mar 27 11:46:09 2017
subProcess 32076 run, Mon Mar 27 11:46:11 2017
Parent process run. subProcess is 32076
Parent process end,Mon Mar 27 11:46:13 2017

這樣所有的進程就能順利的執行了。

⑨ Python多進程運行——Multiprocessing基礎教程2

上篇文章簡單介紹了multiprocessing模塊，本文將要介紹進程之間的數據共享和信息傳遞的概念。

在多進程處理中，所有新創建的進程都會有這兩個特點：獨立運行，有自己的內存空間。

我們來舉個例子展示一下：

這個程序的輸出結果是：

在上面的程序中我們嘗試在兩個地方列印全局列表result的內容：

我們再用一張圖來幫助理解記憶不同進程間的數據關系：

如果程序需要在不同的進程之間共享一些數據的話，該怎麼做呢？不用擔心，multiprocessing模塊提供了Array對象和Value對象，用來在進程之間共享數據。

所謂Array對象和Value對象分別是指從共享內存中分配的ctypes數組和對象。我們直接來看一個例子，展示如何用Array對象和Value對象在進程之間共享數據：

程序輸出的結果如下：

成功了！主程序和p1進程輸出了同樣的結果，說明程序中確實完成了不同進程間的數據共享。那麼我們來詳細看一下上面的程序做了什麼：

在主程序中我們首先創建了一個Array對象：

向這個對象輸入的第一個參數是數據類型：i表示整數，d代表浮點數。第二個參數是數組的大小，在這個例子中我們創建了包含4個元素的數組。

類似的，我們創建了一個Value對象：

我們只對Value對象輸入了一個參數，那就是數據類型，與上述的方法一致。當然，我們還可以對其指定一個初始值（比如10），就像這樣：

隨後，我們在創建進程對象時，將剛創建好的兩個對象：result和square_sum作為參數輸入給進程：

在函數中result元素通過索引進行數組賦值，square_sum通過 value 屬性進行賦值。

注意：為了完整列印result數組的結果，需要使用 result[:] 進行列印，而square_sum也需要使用 value 屬性進行列印：

每當python程序啟動時，同時也會啟動一個伺服器進程。隨後，只要我們需要生成一個新進程，父進程就會連接到伺服器並請求它派生一個新進程。這個伺服器進程可以保存Python對象，並允許其他進程使用代理來操作它們。

multiprocessing模塊提供了能夠控制伺服器進程的Manager類。所以，Manager類也提供了一種創建可以在不同流程之間共享的數據的方法。

伺服器進程管理器比使用共享內存對象更靈活，因為它們可以支持任意對象類型，如列表、字典、隊列、值、數組等。此外，單個管理器可以由網路上不同計算機上的進程共享。

但是，伺服器進程管理器的速度比使用共享內存要慢。

讓我們來看一個例子：

這個程序的輸出結果是：

我們來理解一下這個程序做了什麼：首先我們創建了一個manager對象

在with語句下的所有行，都是在manager對象的范圍內的。接下來我們使用這個manager對象創建了列表（類似的，我們還可以用 manager.dict() 創建字典）。

最後我們創建了進程p1（用於在records列表中插入一條新的record）和p2（將records列印出來），並將records作為參數進行傳遞。

伺服器進程的概念再次用下圖總結一下：

為了能使多個流程能夠正常工作，常常需要在它們之間進行一些通信，以便能夠劃分工作並匯總最後的結果。multiprocessing模塊支持進程之間的兩種通信通道：Queue和Pipe。

使用隊列來回處理多進程之間的通信是一種比較簡單的方法。任何Python對象都可以使用隊列進行傳遞。我們來看一個例子：

上面這個程序的輸出結果是：

我們來看一下上面這個程序到底做了什麼。首先我們創建了一個Queue對象：

然後，將這個空的Queue對象輸入square_list函數。該函數會將列表中的數平方，再使用 put() 方法放入隊列中：

隨後使用 get() 方法，將q列印出來，直至q重新稱為一個空的Queue對象：

我們還是用一張圖來幫助理解記憶：

一個Pipe對象只能有兩個端點。因此，當進程只需要雙向通信時，它會比Queue對象更好用。

multiprocessing模塊提供了 Pipe() 函數，該函數返回由管道連接的一對連接對象。 Pipe() 返回的兩個連接對象分別表示管道的兩端。每個連接對象都有 send() 和 recv() 方法。

我們來看一個例子：

上面這個程序的輸出結果是：

我們還是來看一下這個程序到底做了什麼。首先創建了一個Pipe對象：

與上文說的一樣，該對象返回了一對管道兩端的兩個連接對象。然後使用 send() 方法和 recv() 方法進行信息的傳遞。就這么簡單。在上面的程序中，我們從一端向另一端發送一串消息。在另一端，我們收到消息，並在收到END消息時退出。

要注意的是，如果兩個進程(或線程)同時嘗試從管道的同一端讀取或寫入管道中的數據，則管道中的數據可能會損壞。不過不同的進程同時使用管道的兩端是沒有問題的。還要注意，Queue對象在進程之間進行了適當的同步，但代價是增加了計算復雜度。因此，Queue對象對於線程和進程是相對安全的。

最後我們還是用一張圖來示意：

Python的multiprocessing模塊還剩最後一篇文章：多進程的同步與池化

敬請期待啦！

⑩ 一文帶你讀懂Python中的進程

進程

進程（Process）是計算機中的程序關於某數據集合上的一次運行，即正在運行的程序，是系統進行資源分配和調度的基本單位，進程是對正在運行程序的一個抽象，在早期面向進程設計的計算機結構中，進程是程序的基本執行實體，在當代面向線程設計的計算機結構中，進程是線程的容器，線程是執行的實體。進程的概念起源於操作系統，是操作系統最核心的概念，操作系統的其他所有內容都是圍繞進程的概念展開的。

在早期計算機中可以利用的cpu只有一個，為了充分利用CPU性能，提高用戶操作體驗，出現了多道技術。將一個單獨的cpu虛擬成多個cpu（多道技術：時間多路復用和空間多路復用+硬體上支持隔離），即使在一個單核CPU也能保證支持（偽）並發的能力。如果沒有進程的抽象，現代計算機將不復存在。

狹義定義：進程是正在運行的程序的實例（an instance of a computer program that is being executed）。

廣義定義：進程是一個具有一定獨立功能的程序關於某個數據集合的一次運行活動。它是操作系統動態執行的基本單元，在傳統的操作系統中，進程既是基本的分配單元，也是基本的執行單元。

操作系統的作用：

隱藏復雜的硬體介面，提供良好的抽象介面。

管理、調度進程，使多個進程對硬體的競爭變得有序。

多道技術：針對早期單核CPU，實現多個程序的並發執行，現在的主機一般是多核，每個核都會利用多道技術，如有4個cpu，運行於cpu1的某個程序遇到io阻塞，會等到io結束再重新調度，重新調度是可能會被調度到4個cpu中的任意一個，具體由操作系統調度演算法決定。

多道技術的主要特性如下：

（1）空間上的復用：內存中可以同時有多道程序。

（2）物理隔離：多個程序在內存中都有各自獨立的內存空間，互不影響。

（3）時間上的復用：多個程序在操作系統的調度演算法下，在不同的時間段內分別佔有CPU資源。

需要注意的是如果一個進程長時間佔用CPU資源，操作系統會強制將CPU資源分配給其它在就緒隊列中的程序，避免一個程序長時間佔有CPU資源，導致其它程序無法運行。

python進程同步

與python進程同步相關的資訊