网站怎么做会被收录,做淘宝网站需要多少钱,外包服务美剧,移动网站开发内容Python 三种运行模式
Python作为一门脚本语言#xff0c;使用的范围很广。有的同学用来算法开发#xff0c;有的用来验证逻辑#xff0c;还有的作为胶水语言#xff0c;用它来粘合整个系统的流程。不管怎么说#xff0c;怎么使用python既取决于你自己的业务场景#xff0…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 codeif __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_exit0
def run_thread():
global g_exit
while 0 g_exit:
time.sleep(1)do jobs per threaddef 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就是这么一种模式只不过它使用了clua来开发的。其实只要了解了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 busyg_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(targetrun_thread, args(i,))
td.start()
g_threads.append(td)test thread to give datatest threading.Thread(targettest_thread)
test.start()
while 0 g_exit:
for i in range(g_num):
g_sem[i].release()
time.sleep(1)call all thread to closefor i in range(g_num):
g_sem[i].release()
for i in range(g_num):
g_threads[i].join()
test.join()
print exit nowentryif __name__ __main__:
main()
感谢阅读希望能帮助到大家谢谢大家对本站的支持
