python進程共享內存
❶ 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 有沒有和 C/C++ 進程共享內存的方式
通過share memory 取對象的例子, c write object into memory map, python read it by call dll api.
So there still questions you should consider how to guarantee the process share security. Good luck..
----python part----
from ctypes import *
#windll.kernel32.SetLastError(-100)
print windll.kernel32.GetLastError()
getMessage=windll.kernel32.OpenFileMappingA
getMessage.restype = c_int
handle=getMessage(1,False,"Global\\MyFileMappingObject")
if handle ==0:
print 'open file mapping handle is Null'
else:
mapView=windll.kernel32.MapViewOfFile
mapView.restype = c_char_p
print mapView(handle,1,0,0,256)
----c part----
#include <windows.h>
#include <stdio.h>
#include <conio.h>
#include <tchar.h>
#define BUF_SIZE 256
TCHAR szName[] = TEXT("Global\\MyFileMappingObject");
TCHAR szMsg[] = TEXT("Message from first process.");
int _tmain()
{
HANDLE hMapFile;
LPCTSTR pBuf;
hMapFile = CreateFileMapping(
INVALID_HANDLE_VALUE, // use paging file
NULL, // default security
PAGE_READWRITE, // read/write access
0, // maximum object size (high-order DWORD)
BUF_SIZE, // maximum object size (low-order DWORD)
szName); // name of mapping object
if (hMapFile == NULL)
{
_tprintf(TEXT("Could not create file mapping object (%d).\n"),
GetLastError());
return 1;
}
pBuf = (LPTSTR)MapViewOfFile(hMapFile, // handle to map object
FILE_MAP_ALL_ACCESS, // read/write permission
0,
0,
BUF_SIZE);
if (pBuf == NULL)
{
_tprintf(TEXT("Could not map view of file (%d).\n"),
GetLastError());
CloseHandle(hMapFile);
return 1;
}
CopyMemory((PVOID)pBuf, szMsg, (_tcslen(szMsg) * sizeof(TCHAR)));
_getch();
UnmapViewOfFile(pBuf);
CloseHandle(hMapFile);
return 0;
}
❸ 用python寫一段程序運行後被其他pyhon進程調用應該怎麼做呢
如果你需要那個提供數據的一直運行,那你就需要pipe或者socket。
❹ python multiprocessing怎麼在父進程與子進程間共享一個列表,元素是字典,字典value是一個自定義類。
在multiprocessing當中,可以用shared memory在cpu之間恭喜共享信息.我在優酷里傳了個教程專門版講這個的.你可權以在優酷里搜下(莫煩 共享內存),我還有multiprocessing的一套的教程.
你也可以訂閱我的優酷頻道,我會有很多python基礎知識不斷的更新, 希望你可以幫助到你的學習.
❺ python多進程,多線程分別是並行還是並發
並發和並行
你吃飯吃到一半,電話來了,你一直到吃完了以後才去接,這就說明你不支持並發也不支持並行。
你吃飯吃到一半,電話來了,你停了下來接了電話,接完後繼續吃飯,這說明你支持並發。
你吃飯吃到一半,電話來了,你一邊打電話一邊吃飯,這說明你支持並行。
並發的關鍵是你有處理多個任務的能力,不一定要同時。
並行的關鍵是你有同時處理多個任務的能力。
所以我認為它們最關鍵的點就是:是否是『同時』。
Python 中沒有真正的並行,只有並發
無論你的機器有多少個CPU, 同一時間只有一個Python解析器執行。這也和大部分解釋型語言一致, 都不支持並行。這應該是python設計的先天缺陷。
javascript也是相同的道理, javascript早起的版本只支持單任務,後來通過worker來支持並發。
Python中的多線程
先復習一下進程和線程的概念
所謂進程,簡單的說就是一段程序的動態執行過程,是系統進行資源分配和調度的一個基本單位。一個進程中又可以包含若干個獨立的執行流,我們將這些執行流稱為線程,線程是CPU調度和分配的基本單位。同一個進程的線程都有自己的專有寄存器,但內存等資源是共享的。
這里有一個更加形象的解釋, 出自阮一峰大神的傑作:
http://www.ruanyifeng.com/blog/2013/04/processes_and_threads.html
Python中的thread的使用
通過 thread.start_new_thread 方法
import thread
import time
# Define a function for the thread
def print_time( threadName, delay):
count = 0
while count < 5:
time.sleep(delay)
count += 1
print "%s: %s" % ( threadName, time.ctime(time.time()) )
# Create two threads as follows
try:
thread.start_new_thread( print_time, ("Thread-1", 2, ) )
thread.start_new_thread( print_time, ("Thread-2", 4, ) )
except:
print "Error: unable to start thread"
while 1:
pass
通過繼承thread
#!/usr/bin/python
import threading
import time
exitFlag = 0
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 "Starting " + self.name
print_time(self.name, self.counter, 5)
print "Exiting " + self.name
def print_time(threadName, delay, counter):
while counter:
if exitFlag:
threadName.exit()
time.sleep(delay)
print "%s: %s" % (threadName, time.ctime(time.time()))
counter -= 1
# Create new threads
thread1 = myThread(1, "Thread-1", 1)
thread2 = myThread(2, "Thread-2", 2)
# Start new Threads
thread1.start()
thread2.start()
print "Exiting Main Thread"
線程的同步
#!/usr/bin/python
import threading
import time
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 "Starting " + self.name
# Get lock to synchronize threads
threadLock.acquire()
print_time(self.name, self.counter, 3)
# Free lock to release next thread
threadLock.release()
def print_time(threadName, delay, counter):
while counter:
time.sleep(delay)
print "%s: %s" % (threadName, time.ctime(time.time()))
counter -= 1
threadLock = threading.Lock()
threads = []
# Create new threads
thread1 = myThread(1, "Thread-1", 1)
thread2 = myThread(2, "Thread-2", 2)
# Start new Threads
thread1.start()
thread2.start()
# Add threads to thread list
threads.append(thread1)
threads.append(thread2)
# Wait for all threads to complete
for t in threads:
t.join()
print "Exiting Main Thread"
利用multiprocessing多進程實現並行
進程的創建
Python 中有一套類似多線程API 的的類來進行多進程開發: multiprocessing
這里是一個來自官方文檔的例子:
from multiprocessing import Process
def f(name):
print 'hello', name
if __name__ == '__main__':
p = Process(target=f, args=('bob',))
p.start()
p.join()
類似與線程,一可以通過繼承process類來實現:
from multiprocessing import Process
class Worker(Process):
def run(self):
print("in" + self.name)
if __name__ == '__main__':
jobs = []
for i in range(5):
p = Worker()
jobs.append(p)
p.start()
for j in jobs:
j.join()
進程的通信
Pipe()
pipe()函數返回一對由雙向通信的管道連接的對象,這兩個對象通過send, recv 方法實現 信息的傳遞
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()
Quene
from multiprocessing import Process, Queue
def f(q):
q.put([42, None, 'hello'])
if __name__ == '__main__':
q = Queue()
p = Process(target=f, args=(q,))
p.start()
print q.get() # prints "[42, None, 'hello']"
p.join()
進程間的同步
Python 中多進程中也有類似線程鎖的概念,使用方式幾乎一樣:
from multiprocessing import Process, Lock
def f(l, i):
l.acquire()
print 'hello world', i
l.release()
if __name__ == '__main__':
lock = Lock()
for num in range(10):
Process(target=f, args=(lock, num)).start()
進程間的共享內存
每個進程都有獨自的內存,是不能相互訪問的, 也行 python官方覺得通過進程通信的方式過於麻煩,提出了共享內存的概念,以下是官方給出的例子:
from multiprocessing import Process, Value, Array
def f(n, a):
n.value = 3.1415927
for i in range(len(a)):
a[i] = -a[i]
if __name__ == '__main__':
num = Value('d', 0.0)
arr = Array('i', range(10))
p = Process(target=f, args=(num, arr))
p.start()
p.join()
print num.value
print arr[:]
總結
python通過多進程實現多並行,充分利用多處理器,彌補了語言層面不支持多並行的缺點。Python, Node.js等解釋型語言似乎都是通過這種方式來解決同一個時間,一個解釋器只能處理一段程序的問題, 十分巧妙。
❻ 多進程開發如何共享數據:以python為例
1-redis,2-mysql 3-共享文件 4-manager模塊共享內存變數
❼ 用python多進程模塊multiprocessing創建的子進程如何共享內存空間
進程傳遞數據最簡單方便的是通過Queue。這樣你的自建類對象就可以放到隊列中,由子進程獲取。
到於Array, Var等方法,那是給高效數據共享用的。共享內存是進程通信的高級技巧。需要高性能計算的時候再研究這些方法。
Pool, Manager之類是一種封裝。用得反而比較少。
python與C++共享內存里,還會使用一種Numpy中的數組。那個效率更高。
你的程序中子進程及傳遞參數都沒有問題。你少了一句。在後面要加上
p.join()就可以了
如果不加,那麼你的主進程不等子進程,它先退出了,往往操作系統會自動把子進程也殺掉。
另外子進程中的print輸出有延時。即使你用sys.stdout.flush(),有時候它也會有延時。
❽ python讀取共享內存數據時出現亂碼
1. Python文件設置編碼 utf-8 (文件前面加上 #encoding=utf-8)
2. MySQL資料庫charset=utf-8
3. Python連接MySQL是加上參數 charset=utf8
4. 設置Python的默認編碼為 utf-8 (sys.setdefaultencoding(utf-8)
❾ python中,為什麼採取賦值共享內存的方式
通過來自share memory 取對象的例子, c write object into memory map, python read it by call dll api.
So there still questions you should consider how to guarantee the process share security. Good luck..
----python part----