Detaillierte Einführung in die drei von Python entwickelten Betriebsmodi

In diesem Artikel werden hauptsächlich relevante Informationen zu den drei Betriebsmodi der Python-Entwicklung im Detail vorgestellt. Freunde, die sie benötigen, können sich auf

Drei Betriebsmodi von Python

beziehen Python wird als Skriptsprache in einer Vielzahl von Anwendungen eingesetzt. Einige Studenten verwenden es, um Algorithmen zu entwickeln, andere verwenden es, um die Logik zu überprüfen, und einige verwenden es als Klebesprache, um den gesamten Systemprozess zu binden. In jedem Fall hängt die Verwendung von Python sowohl von Ihren eigenen Geschäftsszenarien als auch von Ihren eigenen Python-Anwendungsfähigkeiten ab. Persönlich denke ich, dass Python sowohl für die Geschäftsentwicklung als auch für die Entwicklung von Produktprototypen verwendet werden kann. Im Allgemeinen arbeitet Python hauptsächlich in den folgenden drei Modi.

1. Single-Loop-Modus

Der Single-Loop-Modus ist der am häufigsten verwendete, einfachste und natürlich stabilste. Warum? Da in einer einzigen Schleife weniger Code geschrieben wird und weniger Fehlermöglichkeiten bestehen, ist die Wahrscheinlichkeit von Fehlern im Allgemeinen sehr gering. Natürlich sagen wir nicht, dass eine einzelne Schleife nutzlos ist, ganz im Gegenteil. Der Single-Loop-Modus ist der Modus, den wir am häufigsten verwenden. Diese Art der Entwicklung eignet sich besonders für einige Gadgets, kleine Anwendungen und kleine Szenen.

#!/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. Multi-Threading-Modus

Der Multi-Threading-Modus wird häufig in Situationen verwendet, in denen dies der Fall ist anfällig für Blockaden. Zum Beispiel Multithread-Client-Lesen und -Schreiben, Multithread-Webzugriff usw. Ein Merkmal von Multithreading besteht darin, dass jeder Thread entsprechend dem Client erstellt wird. Ein einfaches Beispiel ist ein Server-Socket. Verwenden Sie einen Socket, um einen Thread zu erstellen, sodass mehrere Threads gleichzeitig eine Verbindung herstellen. Diese Methode ist relativ einfach und schnell anzuwenden. Der Nachteil besteht darin, dass alle Geschäfte gleichzeitig ausgeführt werden können und der globale Datenschutz sehr mühsam ist.

#!/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. Der Reaktormodus ist nicht kompliziert Multi-Threading für die Abwicklung jedes Unternehmens zu verwenden. Wenn ein Geschäft von einem Thread verarbeitet wurde, können andere Threads das Geschäft nicht erneut verarbeiten. Auf diese Weise entspricht es der Lösung eines Problems, nämlich des zuvor erwähnten Sperrproblems. Daher ist es für Entwickler in diesem Modell eigentlich eine einfache Sache, ein Geschäft zu schreiben, da er sich nur auf sein eigenes Drittel Hektar Land konzentrieren muss. Das zuvor von Yunfeng geschriebene Skynet entsprach einem solchen Modell, wurde jedoch mit C+Lua entwickelt. Solange Sie das Reaktormuster selbst verstehen, spielt es keine Rolle, welche Sprache Sie für die Entwicklung verwenden. Der Schlüssel liegt darin, das Wesen des Reaktors zu verstehen.

Wenn es als Code geschrieben ist, sollte es so aussehen:

#!/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(&#39;1&#39;, (i << 2) + 0)
      add_event(&#39;2&#39;, (i << 2) + 1)
      add_event(&#39;3&#39;, (i << 2) + 2)
      add_event(&#39;4&#39;, (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)

  &#39;&#39;&#39;
  test thread to give data
  &#39;&#39;&#39;
  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)

  &#39;&#39;&#39;
  call all thread to close
  &#39;&#39;&#39;
  for i in range(g_num):
    g_sem[i].release()

  for i in range(g_num):
    g_threads[i].join()

  test.join()
  print &#39;exit now&#39;

&#39;&#39;&#39;
entry
&#39;&#39;&#39;
if __name__ == &#39;__main__&#39;:
  main()

Vielen Dank, Reading, ich hoffe, es kann allen helfen. Vielen Dank für Ihre Unterstützung dieser Website!

Eine ausführlichere Einführung in die drei Betriebsmodi der Python-Entwicklung und verwandte Artikel finden Sie auf der chinesischen PHP-Website!