python编程（python开发的三种运行模式）【转】

版权声明：本文为博主原创文章，未经博主允许不得转载。目录(?)[-] 单循环模式
多线程模式
reactor模式【 声明：版权所有，欢迎转载，请勿用于商业用途。 联系信箱：feixiaoxing @.com】 Python作为一门脚本语言，使用的范围很广。有的同学用来算法开发，有的用来验证逻辑，还有的作为胶水语言，用它来粘合整个系统的流程。不管怎么说，怎么使用python既取决于你自己的业务场景，也取决于你自己的python应用能力。就我个人而言，我觉得python作为既可以用来进行业务的开发，也可以进行产品原型的开发.一般来说，python的运行主要下面这三种模式。
.单循环模式 单循环模式使用的最多，也最简单，当然也最稳定。为什么呢，因为单循环本来代码就写的很少，出错的机会就更少，所以一般只要写对了接口，犯错误的机会还是很低的。当然，我们不是说单循环就没什么用，恰恰相反。单循环模式是我们最经常使用的一种模式。这种开发对于一些小工具、小应用、小场景特别合适。#!/usr/bin/python
import os
import sys
import re
import signal
import timeg_exit = def sig_process(sig, frame):
global g_exit
g_exit =
print 'catch signal'def main():
global g_exit
signal.signal(signal.SIGINT, sig_process)
while == g_exit:
time.sleep() '''
module process code
''' if __name__ == '__main__':
main().多线程模式 多线程模式经常用在那些容易阻塞的场合。比如多线程客户端读写，多线程web访问等等。这里的多线程有个特点，那就是每个线程都是按照客户端创建的。简单的举例就是服务器socket，来一个socket创建一个thread，这样如果存在多个用户的话，就有多个thread并发连接。这种方式比较简单，用起来很快，缺点就是所有业务有可能并发执行，全局数据保护起来很麻烦。#!/usr/bin/python
import os
import sys
import re
import signal
import time
import threadingg_exit=def run_thread():
global g_exit
while == g_exit:
time.sleep() '''
do jobs per thread
'''def sig_process(sig, frame):
global g_exit
g_exit = def main(): global g_exit signal.signal(signal.SIGINT, sig_process)
g_threads = []
for i in range():
td = threading.Thread(target = run_thread)
td.start()
g_threads.append(td) while == g_exit:
time.sleep() for i in range():
g_threads[i].join()if __name__ == '__main__':
main().reactor模式 reactor模式，不复杂，简单的来说，就是利用多线程来处理每一个业务。如果一个业务已经被某一个thread处理了，那么其他的thread就不能再次处理这个业务了。这样，它相当于解决了一个问题，也就是我们在前面所说的锁的问题。因此，对于这种模式的开发者来说，编写业务其实是一件简单的事情，因为他所要关注的只是自己的一亩三分地就可以了。之前云风同学编写的skynet就是这么一种模式，只不过它使用了c+lua来开发的。其实只要了解了reactor模式本身，用什么语言开发不重要，关键是理解reactor的精髓就可以了。 如果写成code，那应该是这样的，#!/usr/bin/pythonimport os
import sys
import re
import time
import signal
import threadingg_num =
g_exit =
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] = [] '''
means idle, means busy
'''
g_event[name].append()
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 != len(g_event[name]):
data = g_event[name][]
del g_event[name][]
g_lock.release()
return name, data
else:
g_event[name][] = for k in g_event:
if == len(g_event[k]):
continue if == g_event[k][]:
continue g_event[k][] =
data = g_event[k][]
del g_event[k][]
g_lock.release()
return k, data g_lock.release()
return '', -def sig_process(sig, frame):
global g_exit
g_exit =
print 'catch signal'def run_thread(num):
global g_exit
global g_sem
global g_lock name = ''
data = - while == 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 == g_exit:
for i in range():
add_event('', (i << ) + )
add_event('', (i << ) + )
add_event('', (i << ) + )
add_event('', (i << ) + ) time.sleep()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()
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 == g_exit:
for i in range(g_num):
g_sem[i].release()
time.sleep() '''
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()