1. Arrêtez le fil

Nous pouvons facilement créer des flux avec des bibliothèques de flux, de sorte qu'il fait ce que nous voulons suivre nos idées, accélérant ainsi l'effet des activités de programme. Cependant, certains nids de poule sont compatibles après la création du flux, il est remis à la mise en œuvre du système d'exploitation. Nous ne pouvons pas mettre fin directement à un thread ou vous ne pouvez pas envoyer le signal, vous ne pouvez pas ajuster sa planification , aucune activité plus avancée. Si vous souhaitez des fonctions pertinentes, vous ne pouvez le développer que vous-même.

Comment grandir? Lorsque nous créons un flux, spécifiez la cible avec la fonction que nous voulons faire

Cette fonction n'est pas nécessairement une fonction globale, peut en réalité être une fonction dans un objet . S'il s'agit d'une fonction de l'objet, nous pouvons obtenir d'autres informations de l'objet dans cette fonction, nous pouvons l'utiliser pour exécuter l'arrêt du flux d'arrêt.la main d'oeuvre.

Cela ne semble pas très bon, mais voyant que le code est vraiment simple:

import timefrom threading import Threadclass TaskWithSwitch: def __init__(self): self._running = True def terminate(self): self._running = False def run(self, n): while self._running and n > 0: print('Running {}'.format(n)) n -= 1 time.sleep(1)c = TaskWithSwitch()t = Thread(target=c.run, args=(10, ))t.start()c.terminate()t.join() Si vous exécutez ce code, vous ne trouverez que 10 sur L'écran, il ne remplira pas les conditions de boucle après que ce champ soit défini sur False. Lorsque le prochain cycle, il ne répondra plus aux conditions du cycle, elle s'échappera.


Si nous voulons lire IO avec de nombreux flux, en raison de IO peut survivre , il peut avoir un flux qui ne peut pas être retourné. Cas. Cela signifie que nous sommes dans le cercle interne. Ce temps utilise simplement _rucks pour évaluer ou suffisamment, nous avons besoin de
Définir la minuterie

dans le flux, empêchant ainsi la carte dans la boucle. Lundi, la transmission du signal fileté

Nous sommes très serrés pour contrôler le fonctionnement des flux, principalement class IOTask: def __init__(self): self._running = True def terminate(self): self._running = False def run(self, sock): # 在socket中设置计时器 sock.settimeout(10) while self._running: try: # 由于设置了计时器，所以这里不会永久等待 data = sock.recv(1024) break except socket.timeout: continue return l'état du débit est inconnu ] et nous ne pouvons pas l'utiliser directement parce qu'il est géré BSystème opérateur. Les principaux sujets que nous courons et le sujet créé est indépendant. Il n'y a pas de relation esclave entre deux personnes, nous souhaitons donc mettre en œuvre le statut des sujets, souvent à faire par d'autres moyens.

Pensez à une scène, supposons que nous ayons une mission, devez commencer à exécuter après un autre thread. Si vous voulez y arriver,

doit avoir un état de sensibilisation au flux

, d'autres flux sont nécessaires pour transmettre des signaux. Nous pouvons utiliser des outils d'événements dans Thimeading pour y parvenir. L'outil d'événement est qu'il peut être utilisé pour transmettre des signaux, c'est comme si c'est un commutateur qui démarrera ce commutateur lorsqu'un thread est exécuté. Cet interrupteur contrôle d'autres opérations logiques.

Voir le code d'échantillon:

Nous effectuons uniquement l'invite de la ligne de sortie dans le flux, sans autre logique. Parce que nous avons dormi 1s dans la fonction run_in_thread, il doit s'agir du flux issu principalementU sorti le sujet principal. Supposons que ce sujet soit une tâche très importante, nous espérons que le sujet principal peut attendre qu'il fonctionne à une scène puis exécuter, que devrions-nous faire? Note,

Il est dit de fonctionner à une étape, pas en cours d'exécution
. Courez tous c'est très bon, vous pouvez le faire en vous joignant. Mais si cela ne fonctionne pas, il est courant de terminer un certain stade, bien sûr, il peut être utilisé par la participation, mais il réduira l'efficacité globale. À ce stade, nous devons utiliser l'événement. Après avoir ajouté l'événement, voir le code:
La logique globale n'a pas beaucoup de modifications, qui consiste à ajouter quelques lignes à utiliser l'événement. Nous import timefrom threading import Thread, Eventdef run_in_thread(): time.sleep(1) print('Thread is running')t = Thread(target=run_in_thread)t.start()print('Main thread print') Si vous souhaitez utiliser l'événement, il est préférable d'utiliser une seule fois en code
. Bien sûr, à travers la méthode claire de l'épreuve, nous pouvons réinitialiser la valeur de l'événement, mais le problème est que nous ne pouvons pas garantir que cette réinitialisation logique sera exécutée avant CHAttendez. S'il est exécuté, il sera inhabituel et il sera inhabituel lorsque le débogage est, car l'erreur n'est pas là, mais parfois, il n'y aura pas d'apparence. Cette situation est généralement due à une utilisation multithreading.
Donc, si vous souhaitez utiliser les commutateurs et les signaux à plusieurs reprises, n'utilisez pas l'événement, vous pouvez utiliser le nombre de sémaphore.

Mardi, le nombre de signaux L'événement est un problème si plusieurs flux attendent l'événement et lorsqu'ils sont placés, ces flux sont effectués simultanément. Mais parfois, nous ne voulons pas cela, nous espérons contrôler ces sujets à courir d'une manière

. Si vous voulez faire cela, l'événement ne peut pas être satisfait et vous devez utiliser le nombre de sémaphore. import timefrom threading import Thread, Eventdef run_in_thread(event): time.sleep(1) print('Thread is running') # set一下event，这样外面wait的部分就会被启动 event.set()# 初始化Eventevent = Event()t = Thread(target=run_in_thread, args=(event, ))t.start()# event等待setevent.wait()print('Main thread print')

Signal Argent et procédés d'utilisation similaire et différente de l'utilisation, SEMAPHORE peut garantir qu'un seul flux soit lancé à chaque fois . Étant donné que la logique de base des deux n'est pas systématiquement, c'est comme un commutateur pour l'événement. Lorsque le commutateur est démarré,Toute la logique associée à cet interrupteur sera exécutée en même temps. Le nombre de classifications est comme une licence, uniquement des sujets agréés. Pour travailler, et la licence ne sera envoyée qu'une seule fois.

Je souhaite utiliser le nombre de signaux sans développer. Luong Bibliothèque nous fournit des outils prêts - Semaphore, veuillez consulter son code d'utilisateur:

Dans le code ci-dessus, nous avons créé 10 flux, bien que ce fil ait été démarré, ils ne font pas La logique, car

SEMA.ACQUIRE est une méthode de blocage n'entendez pas le signal le suspendre tout le chemin.
Après avoir révélé le nombre, le flux est démarré jusqu'à la mise en œuvre. Chaque fois que nous publions un signal, commencez un flux plus. La logique de cela ne devrait pas être déroutant.

Résumé

Parmi les scènes simultanées simultanément, l'utilisation de nombreux flux

ne commence jamais à démarrer certains flux pour effectuer une coopérationDifférents cas

, nous avons besoin de sujets de coopération, vous devez synchroniser, les prendre, c'est très difficile.Si vous ne vous souciez pas, vous aurez une erreur de fantôme, et parfois il est caché, c'est aussi la raison principale de la douleur.# 工作线程def worker(n, sema): # 等待信号量 sema.acquire() print('Working', n)# 初始化sema = threading.Semaphore(0)nworkers = 10for n in range(nworkers): t = threading.Thread(target=worker, args=(n, sema,)) t.start()
Cet article n'est qu'une brève introduction de méthodes de communication de base entre des sujets.Pour ce numéro,

a de meilleures solutions .Nous continuerons à discuter de cette question dans les prochains articles, alors suivez le suivi.