Résumé des threads et coroutines en python

L'éditeur suivant vous apportera une expérience d'apprentissage (partage) sur les threads simples et les coroutines en python. L'éditeur pense que c'est plutôt bien, alors je vais le partager avec vous maintenant et le donner comme référence. Suivons l'éditeur et jetons un coup d'œil.

La prise en charge des threads en python n'est en effet pas suffisante, mais on dit que python dispose d'un module de framework réseau asynchrone complet, j'espère l'apprendre à l'avenir. est une introduction simple aux threads en python Pour résumer

La bibliothèque de threads peut être utilisée pour exécuter des objets appelables Python arbitraires dans un thread séparé. Bien que ce module ne prenne pas suffisamment en charge les opérations liées aux threads, nous pouvons toujours utiliser des threads simples pour gérer les opérations d'E/S afin de réduire le temps de réponse du programme.

from threading import Thread
import time
 
 
def countdown(n):
  while n > 0:
    print('T-minus:', n)
    n -= 1
 
 
t = Thread(target=countdown, args=(10,))
t.start() # 开启线程
 
time.sleep(2)
 
if t.is_alive() is True:
  print("停止线程...")
  t._stop() # 停止线程

La fonction start est utilisée pour démarrer le thread, et la fonction _stop est utilisée pour arrêter le thread. Afin d'éviter des problèmes tels que le blocage lors de l'exécution d'opérations d'E/S dans un thread, après une exécution pendant un certain temps, vous pouvez déterminer si le thread est toujours en vie. Si le thread existe toujours, appelez _stop() pour l'arrêter. empêcher le blocage (vous pouvez encapsuler la fonction _stop dans la classe, je ne l'ai pas fait ici).

Bien sûr, vous pouvez appeler le pool de threads ThreadPool pour le gérer au lieu de créer manuellement des threads. S'il n'est pas nécessaire de partager des variables entre les threads, il est toujours très pratique d'utiliser des threads, ce qui peut réduire de nombreuses opérations gênantes et gagner du temps. Si nous avons besoin de communiquer entre les threads, nous pouvons utiliser des files d'attente pour y parvenir :

from queue import Queue
from threading import Thread
 
 
class kill:
  def terminate(self, t):
    if t.isAlive is True:
      t._stop()
 
 
def product(out_q):
  for i in range(5):
      out_q.put(i)
 
 
def consumer(in_q):
  for i in range(5):
    print(in_q.get())
 
 
q = Queue()
t1 = Thread(target=consumer, args=(q,))
t2 = Thread(target=product, args=(q,))
t1.start()
t2.start()
 
 
k = kill() # 查询线程是否终止，防止阻塞...
k.terminate(t1)
k.terminate(t2)

L'instance Queue sera partagée par tous les threads, et elle possède tous les verrous requis, afin qu'ils puissent Sûr à partager entre un nombre illimité de fils de discussion. Faites attention ici à ne pas utiliser de méthodes de classe de file d'attente autres que les méthodes put() et get() dans les multi-threads, car cela n'est pas fiable dans un environnement multi-thread ! Pour une communication simple et réduite de données dans des threads, des files d'attente peuvent être utilisées. Si les données volumineuses nécessitent une communication interactive, python fournit des modules associés que vous pouvez utiliser spécifiquement dont vous avez besoin de baidu.

La soi-disant coroutine est en fait un programme de rendement dans un environnement monothread.

from collections import deque
 
 
def countdown(n):
  while n > 0:
    print("T-minus", n)
    yield # 返回之后下次直接从这里执行...相当于C#里面得yield return .
    n -= 1
  print("this is countdown!!!")
 
 
def countup(n):
  x = 0
  while x < n:
    print("Counting up", x)
    yield
    x += 1
 
 
class TaskScheduler:
  def init(self):
    self._task_queue = deque()
 
  def new_task(self, task):
    self._task_queue.append(task)
 
  def run(self):
    while self._task_queue:
      task = self._task_queue.popleft()
      try:
        next(task)
        self._task_queue.append(task)
      except StopIteration:
        pass
 
 
sche = TaskScheduler()
sche.new_task(countdown(10))
sche.new_task(countdown(5))
sche.new_task(countup(15))
sche.run()

Ici, je voudrais parler de mon expérience d'utilisation de python pendant cette période, python est en effet bon, mais ses performances sont également critiquées lorsque j'ai commencé. En apprenant Python, je l'ai également fait. Certains des programmes les plus éblouissants semblent au moins de haute qualité, comme l'utilisation du traitement du langage naturel de Python pour effectuer une analyse des sentiments et les programmes d'exploration les plus populaires, ainsi que la création de graphiques d'analyse de données éblouissants. Peu à peu, j'ai abandonné ceux-ci, car le programme ne se concentre pas sur ceux-ci. Tant que vous connaissez la syntaxe de base et comprenez les documents officiels, vous pouvez le faire. L'objectif du code du programme est la performance et l'optimisation. Dans la mesure du possible, écrire un programme avec les fonctions les plus complètes, les meilleures performances et la plus belle structure. En fait, c'est un peu le « soft power culturel » que disent souvent les professeurs de politique. dans un programme devrait être d'intégrer le modèle de conception le plus approprié, de faire l'optimisation de programme la plus complète, d'adopter la structure de données la plus économe en performances, etc.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!