Python 三種運行模式

Python作為一門腳本語言，使用的范圍很廣。有的同學用來算法開發，有的用來驗證邏輯，還有的作為膠水語言，用它來粘合整個系統的流程。不管怎么說，怎么使用python既取決于你自己的業務場景，也取決于你自己的python應用能力。就我個人而言，我覺得python作為既可以用來進行業務的開發，也可以進行產品原型的開發.一般來說，python的運行主要下面這三種模式。

1.單循環模式

單循環模式使用的最多，也最簡單，當然也最穩定。為什么呢，因為單循環本來代碼就寫的很少，出錯的機會就更少，所以一般只要寫對了接口，犯錯誤的機會還是很低的。當然，我們不是說單循環就沒什么用，恰恰相反。單循環模式是我們最經常使用的一種模式。這種開發對于一些小工具、小應用、小場景特別合適。

#!/usr/bin/python

import os

import sys

import re

import signal

import time

g_exit = 0

def sig_process(sig, frame):

global g_exit

g_exit = 1

print 'catch signal'

def main():

global g_exit

signal.signal(signal.SIGINT, sig_process)

while 0 == g_exit:

time.sleep(1)

'''

module process code

'''

if __name__ == '__main__':

main()

2.多線程模式

多線程模式經常用在那些容易阻塞的場合。比如多線程客戶端讀寫，多線程web訪問等等。這里的多線程有個特點，那就是每個線程都是按照客戶端創建的。簡單的舉例就是服務器socket，來一個socket創建一個thread，這樣如果存在多個用戶的話，就有多個thread并發連接。這種方式比較簡單，用起來很快，缺點就是所有業務有可能并發執行，全局數據保護起來很麻煩。

#!/usr/bin/python

import os

import sys

import re

import signal

import time

import threading

g_exit=0

def run_thread():

global g_exit

while 0 == g_exit:

time.sleep(1)

'''

do jobs per thread

'''

def sig_process(sig, frame):

global g_exit

g_exit = 1

def main():

global g_exit

signal.signal(signal.SIGINT, sig_process)

g_threads = []

for i in range(4):

td = threading.Thread(target = run_thread)

td.start()

g_threads.append(td)

while 0 == g_exit:

time.sleep(1)

for i in range(4):

g_threads[i].join()

if __name__ == '__main__':

main()

3.reactor模式

reactor模式，不復雜，簡單的來說，就是利用多線程來處理每一個業務。如果一個業務已經被某一個thread處理了，那么其他的thread就不能再次處理這個業務了。這樣，它相當于解決了一個問題，也就是我們在前面所說的鎖的問題。因此，對于這種模式的開發者來說，編寫業務其實是一件簡單的事情，因為他所要關注的只是自己的一畝三分地就可以了。之前云風同學編寫的skynet就是這么一種模式，只不過它使用了c+lua來開發的。其實只要了解了reactor模式本身，用什么語言開發不重要，關鍵是理解reactor的精髓就可以了。

如果寫成code，那應該是這樣的，

#!/usr/bin/python

import os

import sys

import re

import time

import signal

import threading

g_num = 4

g_exit =0

g_threads = []

g_sem = []

g_lock = threading.Lock()

g_event = {}

def add_event(name, data):

global g_lock

global g_event

if '' == name:

return

g_lock.acquire()

if name in g_event:

g_event[name].append(data)

g_lock.release()

return

g_event[name] = []

'''

0 means idle, 1 means busy

'''

g_event[name].append(0)

g_event[name].append(data)

g_lock.release()

def get_event(name):

global g_lock

global g_event

g_lock.acquire()

if '' != name:

if [] != g_event[name]:

if 1 != len(g_event[name]):

data = g_event[name][1]

del g_event[name][1]

g_lock.release()

return name, data

else:

g_event[name][0] = 0

for k in g_event:

if 1 == len(g_event[k]):

continue

if 1 == g_event[k][0]:

continue

g_event[k][0] =1

data = g_event[k][1]

del g_event[k][1]

g_lock.release()

return k, data

g_lock.release()

return '', -1

def sig_process(sig, frame):

global g_exit

g_exit =1

print 'catch signal'

def run_thread(num):

global g_exit

global g_sem

global g_lock

name = ''

data = -1

while 0 == g_exit:

g_sem[num].acquire()

while True:

name, data = get_event(name)

if '' == name:

break

g_lock.acquire()

print name, data

g_lock.release()

def test_thread():

global g_exit

while 0 == g_exit:

for i in range(100):

add_event('1', (i << 2) + 0)

add_event('2', (i << 2) + 1)

add_event('3', (i << 2) + 2)

add_event('4', (i << 2) + 3)

time.sleep(1)

def main():

global g_exit

global g_num

global g_threads

global g_sem

signal.signal(signal.SIGINT, sig_process)

for i in range(g_num):

sem = threading.Semaphore(0)

g_sem.append(sem)

td = threading.Thread(target=run_thread, args=(i,))

td.start()

g_threads.append(td)

'''

test thread to give data

'''

test = threading.Thread(target=test_thread)

test.start()

while 0 == g_exit:

for i in range(g_num):

g_sem[i].release()

time.sleep(1)

'''

call all thread to close

'''

for i in range(g_num):

g_sem[i].release()

for i in range(g_num):

g_threads[i].join()

test.join()

print 'exit now'

'''

entry

'''

if __name__ == '__main__':

main()

感謝閱讀，希望能幫助到大家，謝謝大家對本站的支持！

創作挑戰賽新人創作獎勵來咯，堅持創作打卡瓜分現金大獎

總結

以上是生活随笔為你收集整理的python编程模式是什么_python 开发的三种运行模式详细介绍的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。