Verwendung von Multithreading in Callback-Funktionen von Python

下面的demo是根据需求写的简单测试脚本

#!/usr/bin/env python
# coding: utf-8
# 第一个列表为依赖组件和版本号，后面紧跟负责人名称
# 接着出现第二个以来组建列表，负责人为空了
# 所以根据需求需要对组件、版本号、负责人进行不同处理
# 这时在for循环中根据if判断，写回调函数处理
# 格式不一致数据的测试数据
a = [[u'tool-1', u'1.9.13'], u'xiaowang', u'xiaoqu', [u'tool-2', u'1.9.23'], [u'tool-3', u'1.9.33'], [u'tool-4', u'1.9.43'], u'pi',[u'tool-5', u'1.9.53']]
# a = [[u'tool-1', u'1.9.13'],u'xiaowang',[u'tool-2', u'1.9.23'],u'xiaowang', [u'tool-3', u'1.9.33'],u'xiaowang']
# a = [[u'tool-1', u'1.9.13']]
# [u'tool-1', u'1.9.13']'
your_pro = a[0]
# print your_pro
# [u'xiaowang', u'xiaoqu', [u'tool-2', u'1.9.23']]
tmp = a[1:]
# print tmp
def git_callback(whole_v, proj_value, name_value):
  # 如果存在负责人存在
  try:
    if type(name_value[0]) is unicode:
      # 对除去列表0个索引的数据（依赖名和版本号）后面的数据进行遍历
      for i in name_value:
        # 碰到后面的数据是列表的进行回调
        if type(i) is list:
          tmp_index = whole_v.index(i)+1
          return git_callback(whole_v, whole_v[whole_v.index(i)], whole_v[tmp_index:])
        else:
          # 打印依赖、版本号 负责人 开始
          print proj_value+i.split()+['start']
    else:
      # 如果负责人后跟的组件这种格式的列表数据为空
      # 也就是只有依赖和版本号列表数据，负责人为空，就打印依赖版本号
      ver = proj_value
      owner = name_value
      if type(owner[0]) is unicode:
        return git_callback(whole_v, ver, owner)
      else:
        print ver
        # 这里是为了判断是不是到列表的最后一位
        # 如果是最后一个值，且不是字符串的Unicode，而是列表
        # 就直接打印出项目
        if whole_v.index(owner[0]) == len(whole_v)-1:
          # 打印最后一个值
          print whole_v[-1:]
        else:
          # 这里比较绕，打印调试吧...
          new_ver = whole_v[whole_v.index(ver)+1]
          owner = whole_v[whole_v.index(ver)+2:]
          return git_callback(whole_v, new_ver, owner)
  except IndexError as e:
    print proj_value
    print e
git_callback(a, your_pro, tmp)

demo的output:

Boom:git_response pirogue$ python test.py
[u'tool-1', u'1.9.13', u'xiaowang', 'start']
[u'tool-1', u'1.9.13', u'xiaoqu', 'start']
[u'tool-2', u'1.9.23']'
[u'tool-3', u'1.9.33']'
[u'tool-4', u'1.9.43', u'pi', 'start']
[u'tool-5', u'1.9.53']'
列表索引超出范围

Python的多线程

Der folgende Code ist ein Code片段, der aus dem Hauptprogramm extrahiert wurde.

from multiprocessing.dummy import Pool as ThreadPool
# Callback, um die unterschiedliche Formatierung der vom Git-Abfrage zurückgegebenen Abhängigkeitsdaten zu beheben
def git_callback(whole_v, proj_value, name_value, git_cookie):
  # 
  whole_v = whole_v
  list_git = []
  if name_value:
    # print name_value
    for i in name_value:
      # print i
      if i:
        if type(i) is list:
          tmp_index = whole_v.index(i)+1
          return git_callback(whole_v, whole_v[whole_v.index(i)], whole_v[tmp_index:], git_cookie)
        else:
          git_cookie = str(git_cookie.split()[0])+" ' "+str(git_cookie.split()[1]
          list_git.append(tuple(git_cookie.split("?"+i.split()))
          print list_git
          pool = ThreadPool(100)
          result = pool.map(pool_git, list_git)
          print result
          pool.close()
          pool.join()          
  else:
    print proj_value

Der obige Code片段 für Multithreading ist ein Callback-Funktion, der nicht vollständig anhand von demo angepasst wurde. Mit demo ist es auch nicht schwer, nach Bedarf anzupassen, und es reicht aus, ihn zu testen.

Empfang mehrerer Parameter in Python-Multithreading

from multiprocessing.dummy import Pool as ThreadPool
pool = ThreadPool(100)
result = pool.map(pool_git, list_git)
print result
pool.close()
pool.join()

pool_git ist die Funktion, die in Multithreading aufgerufen werden muss, und list_git ist der Parameter, den pool_git benötigt. Standardmäßig ist pool_git eine Funktion, die einen Parameter annimmt.

Unsere Funktionen sind oft sehr komplex und erfordern mehrere Parameter, die in pool_git übergeben werden, daher sollte list_git eine Liste aus mehreren Tuples sein.

Beispielcode, der von Ausländern auf Stack Overflow gegeben wurde:

def multi_run_wrapper(args):
  return add(*args)
def add(x,y):
  return x+y
if __name__ == "__main__":
  from multiprocessing import Pool
  pool = Pool(4)
  results = pool.map(multi_run_wrapper,[(1,2),(2,3),(3,4)])
  print results
Ausgabe
[3, 5, 7]

Mehrere Antworten auf Stack Overflow, die Ihnen helfen, besser zu verstehen:

https://stackoverflow.com/Fragen/5442910/python-multiprocessing-pool-map-für-mehrere-argumente

Ich bin sicher, dass Sie das verstehen können~

Mehrere Threads und mehrere Prozesse

from multiprocessing.dummy import Pool as ThreadPool

Mehrere Threads Prozessespool, mit einem CPU-Kern gebunden

from multiprocessing import Pool

Mehrere Prozesse, die auf mehreren CPU-Kernen ausgeführt werden

Wenn Sie nicht verstehen, ob es sich bei der Aufgabe um eine CPU-lastige oder eine IO-lastige Aufgabe handelt, verwenden Sie diese Bibliothek und schreiben Sie beide imports auf, instancezieren Sie sie dann separately und überprüfen Sie die Dauer. Der Gebrauch ist nur durch einige Buchstaben beim Erstellen des Objekts zu ändern. Der Austausch von Pool und ThreadPool.

Zusammenfassung

Die oben genannten Methoden zur Verwendung mehrerer Threads in Callback-Funktionen des Python-Editors haben der Redaktion vorgestellt. Wir hoffen, dass sie Ihnen helfen. Wenn Sie Fragen haben, hinterlassen Sie bitte einen Kommentar, und die Redaktion wird umgehend antworten. Vielen Dank auch für die Unterstützung der Website Yell-Lehrbuch!

Erklärung: Der Inhalt dieses Artikels wurde aus dem Internet entnommen und gehört dem Urheberrecht des jeweiligen Autors. Der Inhalt wurde von Internetbenutzern freiwillig beigesteuert und hochgeladen. Diese Website besitzt keine Eigentumsrechte und hat den Inhalt nicht von Hand bearbeitet. Sie übernimmt auch keine rechtlichen Verantwortlichkeiten. Wenn Sie urheberrechtlich geschützte Inhalte entdecken, sind Sie herzlich eingeladen, eine E-Mail an notice#w zu senden.3codebox.com (Bitte ersetzen Sie # durch @, wenn Sie eine Beschwerde einreichen, und fügen Sie relevante Beweise bei. Sobald die Beschwerde überprüft wurde, wird die Website die beanstandeten urheberrechtlichen Inhalte sofort löschen.)