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

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()

感谢阅读，希望能帮助到大家，谢谢大家对本站的支持！