轉自：http://blog.csdn.net/feixiaoxing/article/details/53980886

版權聲明：本文為博主原創文章，未經博主允許不得轉載。

目錄(?)[-]

    單循環模式
    多線程模式
    reactor模式

【 聲明：版權所有，歡迎轉載，請勿用於商業用途。 聯系信箱：feixiaoxing @163.com】

  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開發的三種運行模式）【轉】