脚本之家，脚本语言编程技术及教程分享平台！
分类导航

Python|VBS|Ruby|Lua|perl|VBA|Golang|PowerShell|Erlang|autoit|Dos|bat|

服务器之家 - 脚本之家 - Python - python 开发的三种运行模式详细介绍

python 开发的三种运行模式详细介绍

2020-09-18 10:33脚本之家 Python

这篇文章主要介绍了python 开发的三种运行模式详细介绍的相关资料,需要的朋友可以参考下

Python 三种运行模式

  Python作为一门脚本语言，使用的范围很广。有的同学用来算法开发，有的用来验证逻辑，还有的作为胶水语言，用它来粘合整个系统的流程。不管怎么说，怎么使用python既取决于你自己的业务场景，也取决于你自己的python应用能力。就我个人而言，我觉得python作为既可以用来进行业务的开发，也可以进行产品原型的开发.一般来说，python的运行主要下面这三种模式。

1.单循环模式

  单循环模式使用的最多，也最简单，当然也最稳定。为什么呢，因为单循环本来代码就写的很少，出错的机会就更少，所以一般只要写对了接口，犯错误的机会还是很低的。当然，我们不是说单循环就没什么用，恰恰相反。单循环模式是我们最经常使用的一种模式。这种开发对于一些小工具、小应用、小场景特别合适。

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
#!/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并发连接。这种方式比较简单，用起来很快，缺点就是所有业务有可能并发执行，全局数据保护起来很麻烦。

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
#!/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的精髓就可以了。 

python 开发的三种运行模式详细介绍

  如果写成code，那应该是这样的，

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
#!/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
  • 运行模式

    • 延伸 · 阅读

    精彩推荐
    最近更新
    编辑推荐
    阅读排行
    热门标签
    2048 　 6006 　 contextlib 　 SLOTS 　 MELIAE 　 FEEDPARSER 　 暂存 　 持久性管理 　 pickle模块 　 THREADING 　 reduce 　 nignx 　 装饰器 　 函数式编程 　 兔子毒药 　 监控文件 　 流量监控 　 Web框架 　 办公工具 　 PIL库 　 高斯模糊 　 wxPython 　 import 　 自定义模块 　 Python开发 　 元类 　 metaclass 　 魔术方法 　 DNSPod 　 动态解析域名 　
    © 2019-2023 脚本之家 | 服务器之家(www.zzvips.com)旗下站点 版权所有关于我们联系我们版权申明网站地图