python資料庫並發
⑴ python用例並發怎麼解決
python-selenium並發執行測試用例(方法一 各模塊每一條並發執行)
總執行代碼:
# coding=utf-8
import unittest,os,time
import HTMLTestRunner
import threading
import sys
sys.path.append('C:/Users/Dell/Desktop/CARE/program')#使用編輯器，要指定當前目錄，不然無法執行第20行代碼
def creatsuite():
casedir = []
list = os.listdir(os.path.dirname(os.getcwd()))#獲取當前路徑的上一級目錄的所有文件夾,這里可以改成絕對路徑(要搜索的文件路徑)
for xx in list:
if "" in xx:
casedir.append(xx)
suite =[]
for n in casedir:
testunit = unittest.TestSuite()
unittest.defaultTestLoader._top_level_dir = None
#（unittest.defaultTestLoader(): defaultTestLoader()類，通過該類下面的discover()方法可自動更具測試目錄start_dir匹配查找測試用例文件（test*.py），
並將查找到的測試用例組裝到測試套件，因此可以直接通過run()方法執行discover）
discover = unittest.defaultTestLoader.discover(str(n),pattern='tet_*.py',top_level_dir=None)
for test_suite in discover:
for test_case in test_suite:
testunit.addTests(test_case)
suite.append(testunit)
return suite, casedir
def runcase(suite,casedir):
lastPath = os.path.dirname(os.getcwd())#獲取當前路徑的上一級
resultDir = lastPath+"\\run\\report\\" #報告存放路徑
now = time.strftime("%Y-%m-%d %H.%M.%S",time.localtime())
filename = resultDir + now +" result.html"
fp = file(filename, 'wb')
proclist=[]
s=0
for i in suite:
runner = HTMLTestRunner.HTMLTestRunner(stream=fp,title=str(casedir[s])+u'測試報告',description=u'用例執行情況：')
proc = threading.Thread(target=runner.run,args=(i,))
proclist.append(proc)
s=s+1
for proc in proclist:
proc.start()
for proc in proclist:
proc.join()
fp.close()
if __name__ == "__main__":
runtmp=creatsuite()
runcase(runtmp[0],runtmp[1])
⑵ python並發編程-Gevent包介紹
Gevent 是一個第三方庫，可以輕鬆通過gevent實現並發同步或中坦舉非同步編程，在gevent中用到的主要模式是Greenlet, 它是以C擴展模塊形式接入Python的輕量級協程。 Greenlet全部運行在主程序操作系統進程的內部，但它們被協作式地調度。信雀
遇到IO阻塞時會自動切換任務
上例gevent.sleep(2)模擬的是gevent可以識別的io阻塞,
而time.sleep(2)或其他的阻塞,gevent是不能直接識別的需要用下面一行代碼,打補丁,就可以識別了
from gevent import monkey;monkey.patch_all()必須放到被打補丁者的前面，如time，socket模塊之前
我們可以用threading.current_thread().getName()來查看每個g1和g2，查看的結果為DummyThread-n，即假賣碧線程
通過gevent實現單線程下的socket並發（from gevent import monkey;monkey.patch_all()一定要放到導入socket模塊之前，否則gevent無法識別socket的阻塞）
服務端
客戶端
多線程並發多個客戶端
⑶ python stackless 怎麼多線程並發
1 介紹
1.1 為什麼要使用Stackless
摘自stackless網站。
Note
Stackless Python 是Python編程語言的一個增強版本，它使程序員從基於線程的編程方式中獲得好處，並避免傳統線程所帶來的性能與復雜度問題。Stackless為 Python帶來的微線程擴展，是一種低開銷、輕量級的便利工具，如果使用得當，可以獲益如下：
改進程序結構
增進代碼可讀性
提高編程人員生產力
- def familyTacoNight():
- husband.eat(dinner)
- wife.eat(dinner)
- son.eat(dinner)
- daughter.eat(dinner)
- Python 2.4.3 Stackless 3.1b3 060504 (#69, May 3 2006, 19:20:41) [MSC v.1310 32
- bit (Intel)] on win32
- Type "help", "right", "credits" or "license" for more information.
- >>> import stackless
- >>>
- >>> def print_x(x):
- ... print x
- ...
- >>> stackless.tasklet(print_x)('one')
- <stackless.tasklet object at 0x00A45870>
- >>> stackless.tasklet(print_x)('two')
- <stackless.tasklet object at 0x00A45A30>
- >>> stackless.tasklet(print_x)('three')
- <stackless.tasklet object at 0x00A45AB0>
- >>>
- >>> stackless.run()
- one
- two
- three
- >>>
- Python 2.4.3 Stackless 3.1b3 060504 (#69, May 3 2006, 19:20:41) [MSC v.1310 32
- bit (Intel)] on win32
- Type "help", "right", "credits" or "license" for more information.
- >>> import stackless
- >>>
- >>> def print_three_times(x):
- ... print "1:", x
- ... stackless.schele()
- ... print "2:", x
- ... stackless.schele()
- ... print "3:", x
- ... stackless.schele()
- ...
- >>>
- >>> stackless.tasklet(print_three_times)('first')
- <stackless.tasklet object at 0x00A45870>
- >>> stackless.tasklet(print_three_times)('second')
- <stackless.tasklet object at 0x00A45A30>
- >>> stackless.tasklet(print_three_times)('third')
- <stackless.tasklet object at 0x00A45AB0>
- >>>
- >>> stackless.run()
- 1: first
- 1: second
- 1: third
- 2: first
- 2: second
- 2: third
- 3: first
- 3: second
- 3: third
- >>>
能夠在微進程之間交換信息。
能夠控制運行的流程。
- C:>c:python24python
- Python 2.4.3 Stackless 3.1b3 060504 (#69, May 3 2006, 19:20:41) [MSC v.1310 32
- bit (Intel)] on win32
- Type "help", "right", "credits" or "license" for more information.
- >>> import stackless
- >>>
- >>> channel = stackless.channel()
- >>>
- >>> def receiving_tasklet():
- ... print "Recieving tasklet started"
- ... print channel.receive()
- ... print "Receiving tasklet finished"
- ...
- >>> def sending_tasklet():
- ... print "Sending tasklet started"
- ... channel.send("send from sending_tasklet")
- ... print "sending tasklet finished"
- ...
- >>> def another_tasklet():
- ... print "Just another tasklet in the scheler"
- ...
- >>> stackless.tasklet(receiving_tasklet)()
- <stackless.tasklet object at 0x00A45B30>
- >>> stackless.tasklet(sending_tasklet)()
- <stackless.tasklet object at 0x00A45B70>
- >>> stackless.tasklet(another_tasklet)()
- <stackless.tasklet object at 0x00A45BF0>
- >>>
- >>> stackless.run()
- Recieving tasklet started
- Sending tasklet started
- send from sending_tasklet
- Receiving tasklet finished
- Just another tasklet in the scheler
- sending tasklet finished
- >>>
- >>> stackless.tasklet(sending_tasklet)()
- <stackless.tasklet object at 0x00A45B70>
- >>> stackless.tasklet(another_tasklet)()
- <stackless.tasklet object at 0x00A45BF0>
- >>>
- >>> stackless.run()
- Sending tasklet started
- Just another tasklet in the scheler
- >>>
- >>> stackless.tasklet(another_tasklet)()
- <stackless.tasklet object at 0x00A45B30>
- >>> stackless.run()
- Just another tasklet in the scheler
- >>>
- >>> #Finally adding the receiving tasklet
- ...
- >>> stackless.tasklet(receiving_tasklet)()
- <stackless.tasklet object at 0x00A45BF0>
- >>>
- >>> stackless.run()
- Recieving tasklet started
- send from sending_tasklet
- Receiving tasklet finished
- sending tasklet finished
- def ping():
- print "PING"
- pong()
- def pong():
- print "PONG"
- ping()
- ping()
- #
- # pingpong_stackless.py
- #
- import stackless
- ping_channel = stackless.channel()
- pong_channel = stackless.channel()
- def ping():
- while ping_channel.receive(): #在此阻塞
- print "PING"
- pong_channel.send("from ping")
- def pong():
- while pong_channel.receive():
- print "PONG"
- ping_channel.send("from pong")
- stackless.tasklet(ping)()
- stackless.tasklet(pong)()
- # 我們需要發送一個消息來初始化這個游戲的狀態
- # 否則，兩個微進程都會阻塞
- stackless.tasklet(ping_channel.send)('startup')
- stackless.run()
- import thread
- import random
- import sys
- import Queue
- class hackysacker:
- counter = 0
- def __init__(self,name,circle):
- self.name = name
- self.circle = circle
- circle.append(self)
- self.messageQueue = Queue.Queue()
- thread.start_new_thread(self.messageLoop,())
- def incrementCounter(self):
- hackysacker.counter += 1
- if hackysacker.counter >= turns:
- while self.circle:
- hs = self.circle.pop()
- if hs is not self:
- hs.messageQueue.put('exit')
- sys.exit()
- def messageLoop(self):
- while 1:
- message = self.messageQueue.get()
- if message == "exit":
- debugPrint("%s is going home" % self.name)
- sys.exit()
- debugPrint("%s got hackeysack from %s" % (self.name, message.name))
- kickTo = self.circle[random.randint(0,len(self.circle)-1)]
- debugPrint("%s kicking hackeysack to %s" % (self.name, kickTo.name))
- self.incrementCounter()
- kickTo.messageQueue.put(self)
- def debugPrint(x):
- if debug:
- print x
- debug=1
- hackysackers=5
- turns = 5
以上是Stackless Python很簡明的釋義，但其對我們意義何在？——就在於Stackless提供的並發建模工具，比目前其它大多數傳統編程語言所提供的，都更加易用： 不僅是Python自身，也包括java、C++，以及其它。盡管還有其他一些語言提供並發特性，可它們要麼是主要用於學術研究的（如 Mozart/Oz），要麼是罕為使用、或用於特殊目的的專業語言（如Erlang）。而使用stackless，你將會在Python本身的所有優勢之 上，在一個（但願）你已經很熟悉的環境中，再獲得並發的特性。
這自然引出了個問題：為什麼要並發？
1.1.1 現實世界就是並發的
現實世界就是「並發」的，它是由一群事物（或「演員」）所組成，而這些事物以一種對彼此所知有限的、鬆散耦合的方式相互作用。傳說中面向對象編程有 一個好處，就是對象能夠對現實的世界進行模擬。這在一定程度上是正確的，面向對象編程很好地模擬了對象個體，但對於這些對象個體之間的交互，卻無法以一種 理想的方式來表現。例如，如下代碼實例，有什麼問題？
第一印象，沒問題。但是，上例中存在一個微妙的安排：所有事件是次序發生的，即：直到丈夫吃完飯，妻子才開始吃；兒子則一直等到母親吃完才吃；而女 兒則是最後一個。在現實世界中，哪怕是丈夫還堵車在路上，妻子、兒子和女兒仍然可以該吃就吃，而要在上例中的話，他們只能餓死了——甚至更糟：永遠沒有人 會知道這件事，因為他們永遠不會有機會拋出一個異常來通知這個世界！
1.1.2 並發可能是(僅僅可能是)下一個重要的編程範式
我個人相信，並發將是軟體世界裡的下一個重要範式。隨著程序變得更加復雜和耗費資源，我們已經不能指望摩爾定律來每年給我們提供更快的CPU了，當 前，日常使用的個人計算機的性能提升來自於多核與多CPU機。一旦單個CPU的性能達到極限，軟體開發者們將不得不轉向分布式模型，靠多台計算機的互相協 作來建立強大的應用（想想GooglePlex）。為了取得多核機和分布式編程的優勢，並發將很快成為做事情的方式的事實標准。
1.2 安裝stackless
安裝Stackless的細節可以在其網站上找到。現在Linux用戶可以通過SubVersion取得源代碼並編譯；而對於Windows用戶， 則有一個.zip文件供使用，需要將其解壓到現有的Python安裝目錄中。接下來，本教程假設Stackless Python已經安裝好了，可以工作，並且假設你對Python語言本身有基本的了解。
2 stackless起步
本章簡要介紹了stackless的基本概念，後面章節將基於這些基礎，來展示更加實用的功能。
2.1 微進程(tasklet)
微進程是stackless的基本構成單元，你可以通過提供任一個Python可調用對象（通常為函數或類的方法）來建立它，這將建立一個微進程並將其添加到調度器。這是一個快速演示:
注意，微進程將排起隊來，並不運行，直到調用stackless.run()。
2.2 調度器(scheler)
調度器控制各個微進程運行的順序。如果剛剛建立了一組微進程，它們將按照建立的順序來執行。在現實中，一般會建立一組可以再次被調度的微進程，好讓每個都有輪次機會。一個快速演示:
注意：當調用stackless.schele()的時候，當前活動微進程將暫停執行，並將自身重新插入到調度器隊列的末尾，好讓下一個微進程被執行。一旦在它前面的所有其他微進程都運行過了，它將從上次 停止的地方繼續開始運行。這個過程會持續，直到所有的活動微進程都完成了運行過程。這就是使用stackless達到合作式多任務的方式。
2.3 通道(channel)
通道使得微進程之間的信息傳遞成為可能。它做到了兩件事：
又一個快速演示:
接收的微進程調用channel.receive()的時候，便阻塞住，這意味著該微進程暫停執行，直到有信息從這個通道送過來。除了往這個通道發送信息以外，沒有其他任何方式可以讓這個微進程恢復運行。
若有其他微進程向這個通道發送了信息，則不管當前的調度到了哪裡，這個接收的微進程都立即恢復執行；而發送信息的微進程則被轉移到調度列表的末尾，就像調用了stackless.schele()一樣。
同樣注意，發送信息的時候，若當時沒有微進程正在這個通道上接收，也會使當前微進程阻塞:
發送信息的微進程，只有在成功地將數據發送到了另一個微進程之後，才會重新被插入到調度器中。
2.4 總結
以上涵蓋了stackless的大部分功能。似乎不多是吧？——我們只使用了少許對象，和大約四五個函數調用，來進行操作。但是，使用這種簡單的API作為基本建造單元，我們可以開始做一些真正有趣的事情。
3 協程(coroutine)
3.1 子常式的問題
大多數傳統編程語言具有子常式的概念。一個子常式被另一個常式（可能還是其它某個常式的子常式）所調用，或返回一個結果，或不返回結果。從定義上說，一個子常式是從屬於其調用者的。
見下例:
有經驗的編程者會看到這個程序的問題所在：它導致了堆棧溢出。如果運行這個程序，它將顯示一大堆討厭的跟蹤信息，來指出堆棧空間已經耗盡。
3.1.1 堆棧
我仔細考慮了，自己對C語言堆棧的細節究竟了解多少，最終還是決定完全不去講它。似乎，其他人對其所嘗試的描述，以及圖表，只有本身已經理解了的人才能看得懂。我將試著給出一個最簡單的說明，而對其有更多興趣的讀者可以從網上查找更多信息。
每當一個子常式被調用，都有一個「棧幀」被建立，這是用來保存變數，以及其他子常式局部信息的區域。於是，當你調用 ping() ，則有一個棧幀被建立，來保存這次調用相關的信息。簡言之，這個幀記載著 ping 被調用了。當再調用 pong() ，則又建立了一個棧幀，記載著 pong 也被調用了。這些棧幀是串聯在一起的，每個子常式調用都是其中的一環。就這樣，堆棧中顯示： ping 被調用所以 pong 接下來被調用。顯然，當 pong() 再調用 ping() ，則使堆棧再擴展。下面是個直觀的表示：
幀 堆棧
1 ping 被調用
2 ping 被調用，所以 pong 被調用
3 ping 被調用，所以 pong 被調用，所以 ping 被調用
4 ping 被調用，所以 pong 被調用，所以 ping 被調用，所以 pong 被調用
5 ping 被調用，所以 pong 被調用，所以 ping 被調用，所以 pong 被調用，所以 ping 被調用
6 ping 被調用，所以 pong 被調用，所以 ping 被調用，所以 pong 被調用，所以 ping 被調用……
現在假設，這個頁面的寬度就表示系統為堆棧所分配的全部內存空間，當其頂到頁面的邊緣的時候，將會發生溢出，系統內存耗盡，即術語「堆棧溢出」。
3.1.2 那麼，為什麼要使用堆棧？
上例是有意設計的，用來體現堆棧的問題所在。在大多數情況下，當每個子常式返回的時候，其棧幀將被清除掉，就是說堆棧將會自行實現清理過程。這一般 來說是件好事，在C語言中，堆棧就是一個不需要編程者來手動進行內存管理的區域。很幸運，Python程序員也不需要直接來擔心內存管理與堆棧。但是由於 Python解釋器本身也是用C實現的，那些實現者們可是需要擔心這個的。使用堆棧是會使事情方便，除非我們開始調用那種從不返回的函數，如上例中的，那 時候，堆棧的表現就開始和程序員別扭起來，並耗盡可用的內存。
3.2 走進協程
此時，將堆棧弄溢出是有點愚蠢的。 ping() 和 pong() 本不是真正意義的子常式，因為其中哪個也不從屬於另一個，它們是「協程」，處於同等的地位，並可以彼此間進行無縫通信。
幀 堆棧
1 ping 被調用
2 pong 被調用
3 ping 被調用
4 pong 被調用
5 ping 被調用
6 pong 被調用
在stackless中，我們使用通道來建立協程。還記得嗎，通道所帶來的兩個好處中的一個，就是能夠控制微進程之間運行的流程。使用通道，我們可以在 ping 和 pong 這兩個協程之間自由來回，要多少次就多少次，都不會堆棧溢出:
你可以運行這個程序要多久有多久，它都不會崩潰，且如果你檢查其內存使用量（使用Windows的任務管理器或Linux的top命令），將會發現 使用量是恆定的。這個程序的協程版本，不管運行一分鍾還是一天，使用的內存都是一樣的。而如果你檢查原先那個遞歸版本的內存用量，則會發現其迅速增長，直 到崩潰。
3.3 總結
是否還記得，先前我提到過，那個代碼的遞歸版本，有經驗的程序員會一眼看出毛病。但老實說，這裡面並沒有什麼「計算機科學」方面的原因在阻礙它的正 常工作，有些讓人堅信的東西，其實只是個與實現細節有關的小問題——只因為大多數傳統編程語言都使用堆棧。某種意義上說，有經驗的程序員都是被洗了腦，從 而相信這是個可以接受的問題。而stackless，則真正察覺了這個問題，並除掉了它。
4 輕量級線程
與當今的操作系統中內建的、和標准Python代碼中所支持的普通線程相比，「微線程」要更為輕量級，正如其名稱所暗示。它比傳統線程佔用更少的內存，並且微線程之間的切換，要比傳統線程之間的切換更加節省資源。
為了准確說明微線程的效率究竟比傳統線程高多少，我們用兩者來寫同一個程序。
4.1 hackysack模擬
Hackysack是一種游戲，就是一夥臟乎乎的小子圍成一個圈，來回踢一個裝滿了豆粒的沙包，目標是不讓這個沙包落地，當傳球給別人的時候，可以耍各種把戲。踢沙包只可以用腳。
在我們的簡易模擬中，我們假設一旦游戲開始，圈裡人數就是恆定的，並且每個人都是如此厲害，以至於如果允許的話，這個游戲可以永遠停不下來。
4.2 游戲的傳統線程版本
⑷ 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一門語言通吃高性能並發，GPU計算和深度學習
第一個就是並發本身所帶來的開銷即新開處理線程、關閉處理線程、多個處理線程時間片輪轉所帶來的開銷。
實際上對於一些邏輯不那麼復雜的場景來說這些開銷甚至比真正的處理邏輯部分代碼的開銷更大。所以我們決定採用基於協程的並發方式，即服務進程只有一個(單cpu)所有的請求數據都由這個服務進程內部來維護，同時服務進程自行調度不同請求的處理順序，這樣避免了傳統多線程並發方式新建、銷毀以及系統調度處理線程的開銷。基於這樣的考慮我們選擇了基於Tornado框架實現api服務的開發。Tornado的實現非常簡潔明了，使用python的生成器作為協程，利用IOLoop實現了調度隊列。
第二個問題是資料庫的性能，這里說的資料庫包括MongoDB和Redis，我這里分開講。
先講MongoDB的問題，MongoDB主要存儲不同的用戶對於驗證的不同設置，比如該顯示什麼樣的圖片。
一開始每次驗證請求都會查詢MongoDB，當時我們的MongoDB是純內存的，同時三台機器組成一個復制集，這樣的組合大概能穩定承載八九千的qps，後來隨著我們驗證量越來越大，這個承載能力逐漸就成為了我們的瓶頸。
為了徹底搞定這個問題，我們提出了最極端的解決方案，乾脆直接把資料庫中的數據完全緩存到服務進程里定期批量更新，這樣查詢的開銷將大大降低。但是因為我們用的是Python，由於GIL的存在，在8核伺服器上會fork出來8個服務進程，進程之間不像線程那麼方便，所以我們基於mmap自己寫了一套夥伴演算法構建了一個跨進程共享緩存。自從這套緩存上線之後，Mongodb的負載幾乎變成了零。
說完了MongoDB再說Redis的問題，Redis代碼簡潔、數據結構豐富、性能強大，唯一的問題是作為一個單進程程序，終究性能是有上限的。
雖然今年Redis發布了官方的集群版本，但是經過我們的測試，認為這套分布式方案的故障恢復時間不夠優秀並且運維成本較高。在Redis官方集群方案面世之前，開源世界有不少proxy方案，比如Twtter的TwemProxy和豌豆莢的Codis。這兩種方案測試完之後給我們的感覺TwemProxy運維還是比較麻煩，Codis使用起來讓人非常心曠神怡，無論是修改配置還是擴容都可以在配置頁面上完成，並且性能也還算不錯，但無奈當時Codis還有比較嚴重的BUG只能放棄之。
幾乎嘗試過各種方案之後，我們還是下決心自己實現一套分布式方案，目的是高度貼合我們的需求並且運維成本要低、擴容要方便、故障切換要快最重要的是數據冗餘一定要做好。
基於上面的考慮，我們確定基於客戶端的分布式方案，通過zookeeper來同步狀態保證高可用。具體來說，我們修改Redis源碼，使其向zookeeper注冊，客戶端由zookeeper上獲取Redis伺服器集群信息並根據統一的一致性哈希演算法來計算數據應該存儲在哪台Redis上，並在哈希環的下一台Redis上寫入一份冗餘數據，當讀取原始數據失敗時可以立即嘗試讀取冗餘數據而不會造成服務中斷。
⑹ python有什麼好的大數據/並行處理框架
從GitHub中整理出的15個最受歡迎的Python開源框架。這些框架包括事件I/O，OLAP，Web開發，高性能網路通信，測試，爬蟲等。
Django: Python Web應用開發框架
Django 應該是最出名的Python框架，GAE甚至Erlang都有框架受它影響。Django是走大而全的方向，它最出名的是其全自動化的管理後台：只需要使用起ORM，做簡單的對象定義，它就能自動生成資料庫結構、以及全功能的管理後台。
Diesel：基於Greenlet的事件I/O框架
Diesel提供一個整潔的API來編寫網路客戶端和伺服器。支持TCP和UDP。
Flask：一個用Python編寫的輕量級Web應用框架
Flask是一個使用Python編寫的輕量級Web應用框架。基於Werkzeug WSGI工具箱和Jinja2
模板引擎。Flask也被稱為「microframework」，因為它使用簡單的核心，用extension增加其他功能。Flask沒有默認使用的數
據庫、窗體驗證工具。
Cubes：輕量級Python OLAP框架
Cubes是一個輕量級Python框架，包含OLAP、多維數據分析和瀏覽聚合數據（aggregated data）等工具。
Kartograph.py：創造矢量地圖的輕量級Python框架
Kartograph是一個Python庫，用來為ESRI生成SVG地圖。Kartograph.py目前仍處於beta階段，你可以在virtualenv環境下來測試。
Pulsar：Python的事件驅動並發框架
Pulsar是一個事件驅動的並發框架，有了pulsar，你可以寫出在不同進程或線程中運行一個或多個活動的非同步伺服器。
Web2py：全棧式Web框架
Web2py是一個為Python語言提供的全功能Web應用框架，旨在敏捷快速的開發Web應用，具有快速、安全以及可移植的資料庫驅動的應用，兼容Google App Engine。
Falcon：構建雲API和網路應用後端的高性能Python框架
Falcon是一個構建雲API的高性能Python框架，它鼓勵使用REST架構風格，盡可能以最少的力氣做最多的事情。
Dpark：Python版的Spark
DPark是Spark的Python克隆，是一個Python實現的分布式計算框架，可以非常方便地實現大規模數據處理和迭代計算。DPark由豆瓣實現，目前豆瓣內部的絕大多數數據分析都使用DPark完成，正日趨完善。
Buildbot：基於Python的持續集成測試框架
Buildbot是一個開源框架，可以自動化軟體構建、測試和發布等過程。每當代碼有改變，伺服器要求不同平台上的客戶端立即進行代碼構建和測試，收集並報告不同平台的構建和測試結果。
Zerorpc：基於ZeroMQ的高性能分布式RPC框架
Zerorpc是一個基於ZeroMQ和MessagePack開發的遠程過程調用協議（RPC）實現。和 Zerorpc 一起使用的 Service API 被稱為 zeroservice。Zerorpc 可以通過編程或命令行方式調用。
Bottle: 微型Python Web框架
Bottle是一個簡單高效的遵循WSGI的微型python Web框架。說微型，是因為它只有一個文件，除Python標准庫外，它不依賴於任何第三方模塊。
Tornado：非同步非阻塞IO的Python Web框架
Tornado的全稱是Torado Web Server，從名字上看就可知道它可以用作Web伺服器，但同時它也是一個Python Web的開發框架。最初是在FriendFeed公司的網站上使用，FaceBook收購了之後便開源了出來。
webpy: 輕量級的Python Web框架
webpy的設計理念力求精簡（Keep it simple and powerful），源碼很簡短，只提供一個框架所必須的東西，不依賴大量的第三方模塊，它沒有URL路由、沒有模板也沒有資料庫的訪問。
Scrapy：Python的爬蟲框架
Scrapy是一個使用Python編寫的，輕量級的，簡單輕巧，並且使用起來非常的方便。