導航:首頁 > 編程語言 > python中進程間通信

python中進程間通信

發布時間:2022-10-07 00:21:57

python進程間通信queue 是消息隊列嗎

python進程間通信queue 是消息隊列
在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()

❷ Python的多進程模塊multiprocessing

眾所周知,Python中不存在真正的多線程,Python中的多線程是一個並發過程。如果想要並行的執行程序,充分的利用cpu資源(cpu核心),還是需要使用多進程解決的。其中multiprocessing模塊應該是Python中最常用的多進程模塊了。

基本上multiprocessing這個模塊和threading這個模塊用法是相同的,也是可以通過函數和類創建進程。

上述案例基本上就是筆者搬用了上篇文章多線程的案例,可見其使用的相似之處。導入multiprocessing後實例化Process就可以創建一個進程,參數的話也是和多線程一樣,target放置進程執行函數,args存放該函數的參數。

使用類來創建進程也是需要先繼承multiprocessing.Process並且實現其init方法。

Pool可以提供指定數量的進程,供用戶調用,當有新的請求提交到pool中時,如果池還沒有滿,那麼就會創建一個新的進程用來執行該請求。

但如果池中的進程數已經達到規定最大值,那麼該請求就會等待,直到池中有進程結束,才會創建新的進程。

需要注意的是,在調用join方法阻塞進程前,需要先調用close方法,,否則程序會出錯。

在上述案例中,提到了非阻塞,當把創建進程的方法換為pool.apply(func, (msg,))時,就會阻塞進程,出現下面的狀況。

在multiprocessing模塊中還存在Queue對象,這是一個進程的安全隊列,近似queue.Queue。隊列一般也是需要配合多線程或者多進程使用。

下列案例是一個使用進程隊列實現的生產者消費者模式。

multiprocessing支持兩種進程間的通信,其中一種便是上述案例的隊列,另一種則稱作管道。在官方文檔的描述中,multiprocessing中的隊列是基於管道實現的,並且擁有更高的讀寫效率。

管道可以理解為進程間的通道,使用Pipe([plex])創建,並返回一個元組(conn1,conn2)。如果plex被置為True(默認值),那麼該管道是雙向的,如果plex被置為False,那麼該管道是單向的,即conn1隻能用於接收消息,而conn2僅能用於發送消息。

其中conn1、conn2表示管道兩端的連接對象,每個連接對象都有send()和recv()方法。send和recv方法分別是發送和接受消息的方法。例如,可以調用conn1.send發送消息,conn1.recv接收消息。如果沒有消息可接收,recv方法會一直阻塞。如果管道已經被關閉,那麼recv方法會拋出EOFError。

關於multiprocessing模塊其實還有很多實用的類和方法,由於篇幅有限(懶),筆者就先寫到這里。該模塊其實用起來很像threading模塊,像鎖對象和守護線程(進程)等multiprocessing模塊也是有的,使用方法也近乎相同。

如果想要更加詳細的了解multiprocessing模塊,請參考官方文檔。

❸ python進程間通信queue 是消息隊列嗎

從web應用中添加過來的(上面省略了bottle的代碼),開了一個進程,不斷從queue中讀取數據,並進行處理(省略了處理過程)。 邏輯是沒錯的,但是在實際測試的時候,發現一個問題。

❹ 如何實現 C/C++ 與 Python 的通信

這個可以稱之為 兩個軟體(進程)之間的通信。 進程間通信主要包括管道, 系統IPC(包括消息隊列,信號量,共享存儲), SOCKET. 比如: 你可以共同訪問計算機上的一個 txt文件 也可以使用 socket 通信 也可以使用資料庫, 等等 都能達到通信的目的

❺ 如何實現C/C++與Python的通信

這個可以稱之為兩個軟體(進程)之間的通信。

進程間通信主要包括管道, 系統IPC(包括消息隊列,信號量,共享存儲), SOCKET.

比如:你可以共同訪問計算機上的一個txt文件
也可以使用socket通信
也可以使用資料庫,
等等
都能達到通信的目的

❻ 如何實現Python多進程http伺服器

埠只能綁定一個進程。
1 換成線程實現 SocketServer.ThreadingTCPServer
2 主進程調度分發。主進程收到埠請求後通過進程間通信讓其他進程工作。
我想要用 python 的 multiprocessing 模塊實現一個多進程多線程的 http 伺服器,伺服器會使用進程池 Pool 創建多個子進程,然後每個子進程再用 socketserver 創建多線程的 http 伺服器,但是現在我遇到一個問題,就是伺服器運行以後,只有第一個子進程可以處理 http 連接,如何做到讓每一個子進程都可以處理連接?
備註:通過 getpid 可以看到每次接受請求的都是同一個子進程
# Python 3import os, socketserver, signal, sysfrom multiprocessing import Poolclass MyTCPHandler(socketserver.BaseRequestHandler):

def handle(self):
self.data = self.request.recv(1024)
respone = b'HTTP/1.1 200 OK\r\n\r\nOK%d' % os.getpid()
self.request.sendall(respone)def httpd_task():
socketserver.ThreadingTCPServer.allow_reuse_address = True
server = socketserver.ThreadingTCPServer(('0.0.0.0', 80), MyTCPHandler) try:
server.serve_forever() except: pass
server.server_close()if __name__=='__main__':

p = Pool(4) for i in range(4):
p.apply_async(httpd_task)
p.close()
p.join()

❼ 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進程間通信怎麼理解

在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線程間通信的問題,回答有加分!300

pyqt的線程之間的通信是通過信號to槽來實現的,首先你在線程類裡面聲明一個全局槽比如:

classimThread(QtCore.QThread):
imslot=QtCore.pyqtSignal()

這里是要重點注意,上面的是沒有任何參數的一個信號,如果你需要參數的話,你可以在裡面添加參數類型,例如:

imslot1=QtCore.pyqtSignal(str)#這是一個帶字元串參數的信號
imslot2=QtCore.pyqtSignal(int)#這是一個帶整型參數的信號
imslot3=QtCore.pyqtSignal(bool)#這是一個帶布爾參數的信號

當然了,如果你需要多個參數的話,同樣地往裡面加就是了,qt也沒有要求參數必須是同類型的,所以可以這樣:

imslot1=QtCore.pyqtSignal(str,int)#這是一個帶整型和字元串的參數信號
imslot2=QtCore.pyqtSignal(int,str,str)#這是一個帶整型和兩個字元串的參數信號
imslot3=QtCore.pyqtSignal(bool,str)#這是一個帶布爾和字元串的參數信號

在線程的run方法裡面來定義執行信號:

self.imslot.emit()

這里也是需要重點注意的是,上面這個介面是沒有參數的,如果你是要參數的話,是需要這樣寫:

self.imslot1[str].emit('hello')
self.imslot2[int].emit(1)
self.imslot3[bool].emit(False)

多參數的是這樣

self.imslot1[str,int].emit('hello',1)
self.imslot2[int,str,str].emit(1,"hello","world")
self.imslot3[bool,str].emit(False,'hello')

以上就是在線程類裡面完成信號定義了,接下來就是邏輯層成定義一個函數槽來連接線程類裡面的信號,這個也很簡單,比如我在主線程類裡面定義一個方法:

defimSlot():
print'ok'

以上這個是槽函數,接下來是實現信號槽的連接

imThread.imslot.connect('imSlot')

這個就是信號槽的連接方式,當然了,這個是沒有參數的一個信號槽,那麼帶參數的怎麼寫呢?也很簡單!首先定義一個槽函數:

defimSlot(para):
printpara

這個是帶參數的槽函數,下面是:

imThread.imslot[str].connect('imSlot')

以上就是線程之間的方法了,子線程在執行的通行經過執行信號的話,子線程可以安全地執行而不會出現GUI主線程卡死的情況了。

❿ Linux平台下python中有什麼方法可以與一個進程通信

本文實例講解了python實現兩個程序之間通信的方法,具體方法如下:
該實例採用socket實現,與socket網路編程不一樣的是socket.socket(socket.AF_UNIX, socket.SOCK_STREAM)的第一個參數是socket.AF_UNIX
而不是 socket.AF_INET
例中兩個python程序 s.py/c.py 要先運行s.py
基於fedora13/python2.6測試,成功實現!
s.py代碼如下:
#!/usr/bin/env python
import socket
import os

if __name__ == '__main__':
sock = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM)
conn = '/tmp/conn'
if not os.path.exists(conn):
os.mknod(conn)
if os.path.exists(conn):
os.unlink(conn)
sock.bind(conn)
sock.listen(5)
while True:
connection,address = sock.accept()
data = connection.recv(1024)
if data == "hello,server":
print "the client said:%s!\n" % data
connection.send("hello,client")
connection.close()

c.py代碼如下:
#!/usr/bin/env python
import socket
import time

if __name__ == '__main__':
sock = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM)
conn = '/tmp/conn'
sock.connect(conn)
time.sleep(1)
sock.send('hello,server')
print sock.recv(1024)
sock.close()

閱讀全文

與python中進程間通信相關的資料

熱點內容
男主是牛郎鴨子的小說 瀏覽:755
李時珍的電影全部 瀏覽:227
安卓10編譯伺服器硬體配置 瀏覽:957
什麼樣的主機適合當伺服器 瀏覽:856
衣服哪裡進貨app 瀏覽:516
解壓神器魔術 瀏覽:770
寬頻連接2如何連接伺服器地址 瀏覽:365
隨機信號估計演算法 瀏覽:860
安卓如何重壓開槍 瀏覽:377
航天時代飛鵬圖像處理演算法 瀏覽:521
php比較兩個文件 瀏覽:737
加密貨幣市場活躍 瀏覽:334
最便宜的雲盤伺服器架設傳奇 瀏覽:790
java反向工程 瀏覽:110
pdf文檔轉換excel 瀏覽:8
主角叫楚天的都市小說 瀏覽:754
程序員三重境界 瀏覽:871
菜雞方舟上怎麼開伺服器 瀏覽:727
馬林固件編譯錯誤 瀏覽:910
市場營銷案例pdf 瀏覽:770