Metodi di utilizzo delle thread in una funzione di callback in Python

Il seguente demo è uno script di test semplice scritto in base alle esigenze

#!/usr/bin/env python
# coding: utf-8
# Il primo elenco è il componente dipendente e il numero di versione, seguito dal nome del responsabile
# Successivamente, appare un secondo elenco di componenti dipendenti, il responsabile è vuoto
# Pertanto, in base alle esigenze, è necessario trattare componenti, numeri di versione e responsabili in modo diverso
# In questo momento, nel ciclo for, scrivere la funzione di callback basata su if
# Dati di test per dati con formato不一致
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):
  # Se esiste un responsabile
  try:
    if type(name_value[0]) is unicode:
      # Eseguire la scansione dei dati successivi all'indice 0 dell'elenco (nome dipendente e numero di versione)
      for i in name_value:
        # Si incontra dati successivi che sono elenchi, eseguire il callback
        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:
          # Stampa dipendenza, numero di versione, responsabile, start
          print proj_value+i.split()+['start']
    else:
      # Se i dati della lista di componenti seguiti dal responsabile sono vuoti
      # Ovvero ci sono solo liste di dati di dipendenza e numero di versione, il responsabile è vuoto, quindi stampiamo il numero di versione della dipendenza
      ver = proj_value
      owner = name_value
      if type(owner[0]) is unicode:
        return git_callback(whole_v, ver, owner)
      else:
        print ver
        # Questo è per determinare se siamo all'ultimo elemento della lista
        # Se è l'ultimo valore e non una stringa Unicode, ma una lista
        # Stampa direttamente il progetto
        if whole_v.index(owner[0]) == len(whole_v)-1:
          # Stampa l'ultimo valore
          print whole_v[-1:]
        else:
          # Ecco un po' ingarbugliato, stampiamo la debug...
          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)

Output di demo:

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']
Index out of range

Multithreading in Python

Il seguente codice è un frammento estratto dal programma principale

from multiprocessing.dummy import Pool as ThreadPool
Callback per determinare il formato non unico dei dati di dipendenza restituiti dalla query git
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

Il frammento di codice multithread qui sopra è una funzione di callback, non completamente modificata in base a demo. Con demo, è facile modificarla secondo necessità, basta fare più debug.

Ricezione di più parametri in modo multithread in Python

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 è la funzione che devi chiamare in modo multithread, list_git è il parametro che la funzione pool_git deve ricevere, per default pool_git è una funzione che accetta un singolo parametro.

Ma spesso progettiamo funzionalità con logica complessa, che richiedono di passare più parametri a pool_git. In questo caso, list_git dovrebbe fornire una lista di tuple.

Esempio di codice fornito dagli stranieri su stackoverflow:

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
output
[3, 5, 7]

Più risposte su Stack Overflow per aiutarti a capire meglio:

https://stackoverflow.com/questions/5442910/python-multiprocessing-pool-map-for-multiple-arguments

Spero che tu, intelligente, possa capirlo~

Multithreading e multiprocessing

from multiprocessing.dummy import Pool as ThreadPool

Multiprocessing pool di thread, vincolato a un core CPU

from multiprocessing import Pool

Multiprocessing, eseguito su più core CPU

Se non sai se il tuo compito è CPU-intensive o I/O-intensive, usa questa libreria e scrivi entrambi gli import, quindi esegui l'istanziazione separatamente per sapere quanto tempo ci vuole. Il metodo di utilizzo è solo cambiare alcune lettere nella creazione dell'oggetto per scambiare Pool e ThreadPool.

Conclusione

Come ha spiegato l'editor a tutti di come utilizzare più thread nelle funzioni di callback Python, speriamo che sia utile a tutti. Se avete qualsiasi domanda, lasciate un commento e l'editor risponderà prontamente. In questo senso, ringraziamo anche tutti i sostenitori del sito web Tutorial Yell.

Dichiarazione: il contenuto di questo articolo è stato raccolto da Internet, il copyright spetta agli autori originali, il contenuto è stato contribuito e caricato autonomamente dagli utenti di Internet, il sito web non detiene i diritti di proprietà, non è stato elaborato manualmente e non assume alcuna responsabilità legale correlata. Se trovi contenuti sospetti di violazione del copyright, ti preghiamo di inviare una email a: notice#oldtoolbag.com (al momento dell'invio dell'email, sostituisci # con @) per segnalare il problema e fornire prove pertinenti. Una volta verificata, il sito eliminerà immediatamente i contenuti sospetti di violazione del copyright.