Heim > Artikel > Backend-Entwicklung > Detaillierte Einführung in die Positionierung und Zerstörung in Python-Threads (mit Beispielen)
Detaillierte Einführung in die Positionierung und Zerstörung in Python-Threads (mit Beispielen)
- 不言nach vorne
- 2019-02-20 14:41:522420Durchsuche
Dieser Artikel bietet Ihnen eine detaillierte Einführung in die Positionierung und Zerstörung in Python-Threads (mit Beispielen). Freunde in Not können darauf verweisen.
Bevor die Arbeit begann, hatte ich das Gefühl, dass etwas nicht stimmte, und ich hatte das Gefühl, ich würde die Schuld auf mich nehmen. Nein, es ist der dritte Arbeitstag, der mir ein schlechtes Gewissen macht.
Wir haben ein erstaunliches Hintergrundprogramm, das Module dynamisch laden und in einem Thread ausführen kann. Auf diese Weise werden die Funktionen des Plug-Ins realisiert. Wenn das Modul aktualisiert wird, wird das Hintergrundprogramm selbst nicht beendet. Es wird nur der dem Modul entsprechende Thread geschlossen, der Code aktualisiert und dann gestartet.
Also habe ich ein Modul geschrieben, um meine Fähigkeiten unter Beweis zu stellen, aber ich habe vergessen, die Exit-Funktion zu schreiben, was dazu führte, dass bei jeder Aktualisierung des Moduls ein neuer Thread erstellt wurde, sofern das Programm nicht neu gestartet wurde am Leben bleiben.
Das ist nicht möglich, wir müssen einen Weg finden, es aufzuräumen, sonst fürchte ich, dass es explodiert.
Wie reinigt man es? Mir fallen nur zwei Schritte ein:
Finde die Thread-Nummer heraus, die bereinigt werden muss
Zerstöre sie
#coding: utf8
import threading
import os
import time
def tt():
info = threading.currentThread()
while True:
print 'pid: ', os.getpid()
print info.name, info.ident
time.sleep(3)
t1 = threading.Thread(target=tt)
t1.setName('OOOOOPPPPP')
t1.setDaemon(True)
t1.start()
t2 = threading.Thread(target=tt)
t2.setName('EEEEEEEEE')
t2.setDaemon(True)
t2.start()
t1.join()
t2.join()Ausgabe:
root@10-46-33-56:~# python t.py pid: 5613 OOOOOPPPPP 139693508122368 pid: 5613 EEEEEEEEE 139693497632512 ...Sie können sehen, dass der in Python ausgegebene Thread-Name was ist Das haben wir eingestellt, aber das Ergebnis von Ps lässt mich am Leben zweifeln:
root@10-46-33-56:~# ps -Tp 5613 PID SPID TTY TIME CMD 5613 5613 pts/2 00:00:00 python 5613 5614 pts/2 00:00:00 python 5613 5615 pts/2 00:00:00 pythonNormalerweise sollte es nicht so sein. Habe ich mich die ganze Zeit falsch daran erinnert? Verwenden Sie zum Testen eine andere Sprachversion von Multithreading: C-Version von Multithreading
#include<stdio.h>
#include<sys>
#include<sys>
#include<pthread.h>
void *test(void *name)
{
pid_t pid, tid;
pid = getpid();
tid = syscall(__NR_gettid);
char *tname = (char *)name;
// 设置线程名字
prctl(PR_SET_NAME, tname);
while(1)
{
printf("pid: %d, thread_id: %u, t_name: %s\n", pid, tid, tname);
sleep(3);
}
}
int main()
{
pthread_t t1, t2;
void *ret;
pthread_create(&t1, NULL, test, (void *)"Love_test_1");
pthread_create(&t2, NULL, test, (void *)"Love_test_2");
pthread_join(t1, &ret);
pthread_join(t2, &ret);
}</pthread.h></sys></sys></stdio.h>Ausgabe:
root@10-46-33-56:~# gcc t.c -lpthread && ./a.out pid: 5575, thread_id: 5577, t_name: Love_test_2 pid: 5575, thread_id: 5576, t_name: Love_test_1 pid: 5575, thread_id: 5577, t_name: Love_test_2 pid: 5575, thread_id: 5576, t_name: Love_test_1 ...Verwenden Sie den PS-Befehl, um erneut zu überprüfen:
root@10-46-33-56:~# ps -Tp 5575 PID SPID TTY TIME CMD 5575 5575 pts/2 00:00:00 a.out 5575 5576 pts/2 00:00:00 Love_test_1 5575 5577 pts/2 00:00:00 Love_test_2Das ist richtig, der Threadname ist tatsächlich über PS zu sehen! Aber warum kann ich die Python-Version nicht sehen? Da der Thread-Name durch
festgelegt wird, werfen wir einen Blick auf die Definition: setName
[threading.py] class Thread(_Verbose): ... @property def name(self): """A string used for identification purposes only. It has no semantics. Multiple threads may be given the same name. The initial name is set by the constructor. """ assert self.__initialized, "Thread.__init__() not called" return self.__name @name.setter def name(self, name): assert self.__initialized, "Thread.__init__() not called" self.__name = str(name) def setName(self, name): self.name = name ...Was Sie hier sehen, ist, dass es nur die Eigenschaften des
-Objekts festlegt und es nicht berührt hat die Grundlagen, also muss es so sein, dass ich es nicht sehen kann~Thread
oder ps nach Python-Thread-Namen suchen können, also können wir nur lösen es in Python. /proc/
kann dieses Problem perfekt lösen! Warum?threading.enumerate
Thread-Objekte zurückgegeben werden, mit Ausnahme beendeter und nicht gestarteter Objekte.
[threading.py] def enumerate(): """Return a list of all Thread objects currently alive. The list includes daemonic threads, dummy thread objects created by current_thread(), and the main thread. It excludes terminated threads and threads that have not yet been started. """ with _active_limbo_lock: return _active.values() + _limbo.values()Da wir das Thread-Objekt erhalten, können wir dadurch die Informationen zum Thread erhalten! Bitte sehen Sie sich das vollständige Codebeispiel an:
#coding: utf8
import threading
import os
import time
def get_thread():
pid = os.getpid()
while True:
ts = threading.enumerate()
print '------- Running threads On Pid: %d -------' % pid
for t in ts:
print t.name, t.ident
print
time.sleep(1)
def tt():
info = threading.currentThread()
pid = os.getpid()
while True:
print 'pid: {}, tid: {}, tname: {}'.format(pid, info.name, info.ident)
time.sleep(3)
return
t1 = threading.Thread(target=tt)
t1.setName('Thread-test1')
t1.setDaemon(True)
t1.start()
t2 = threading.Thread(target=tt)
t2.setName('Thread-test2')
t2.setDaemon(True)
t2.start()
t3 = threading.Thread(target=get_thread)
t3.setName('Checker')
t3.setDaemon(True)
t3.start()
t1.join()
t2.join()
t3.join()Ausgabe:
root@10-46-33-56:~# python t_show.py pid: 6258, tid: Thread-test1, tname: 139907597162240 pid: 6258, tid: Thread-test2, tname: 139907586672384 ------- Running threads On Pid: 6258 ------- MainThread 139907616806656 Thread-test1 139907597162240 Checker 139907576182528 Thread-test2 139907586672384 ------- Running threads On Pid: 6258 ------- MainThread 139907616806656 Thread-test1 139907597162240 Checker 139907576182528 Thread-test2 139907586672384 ------- Running threads On Pid: 6258 ------- MainThread 139907616806656 Thread-test1 139907597162240 Checker 139907576182528 Thread-test2 139907586672384 ------- Running threads On Pid: 6258 ------- MainThread 139907616806656 Checker 139907576182528 ...Der Code sieht etwas lang aus, aber die Logik ist recht einfach, sowohl
als auch Thread-test1 werden ausgedruckt Die aktuelle PID, Thread-ID und Thread-Name, und dann nach 3 Sekunden beenden Dies dient dazu, das normale Beenden des Threads zu simulieren. Thread-test2
-Thread gibt jede Sekunde alle aktiven Threads im aktuellen Prozess bis Checker aus. threading.enumerate
und Thread-test1 am Anfang sichtbar sind. Beim Verlassen sind nur noch Thread-test2 und MainThread selbst übrig. Checker
ist schwarz geworden und verrückt geworden und wir müssen es stoppen. Dann können wir es auf diese Weise lösen: Thread-test2
def _async_raise(tid, exctype):
"""raises the exception, performs cleanup if needed"""
tid = ctypes.c_long(tid)
if not inspect.isclass(exctype):
exctype = type(exctype)
res = ctypes.pythonapi.PyThreadState_SetAsyncExc(tid, ctypes.py_object(exctype))
if res == 0:
raise ValueError("invalid thread id")
elif res != 1:
ctypes.pythonapi.PyThreadState_SetAsyncExc(tid, None)
raise SystemError("PyThreadState_SetAsyncExc failed")
def stop_thread(thread):
_async_raise(thread.ident, SystemExit)
def get_thread():
pid = os.getpid()
while True:
ts = threading.enumerate()
print '------- Running threads On Pid: %d -------' % pid
for t in ts:
print t.name, t.ident, t.is_alive()
if t.name == 'Thread-test2':
print 'I am go dying! Please take care of yourself and drink more hot water!'
stop_thread(t)
print
time.sleep(1)Ausgabe
root@10-46-33-56:~# python t_show.py pid: 6362, tid: 139901682108160, tname: Thread-test1 pid: 6362, tid: 139901671618304, tname: Thread-test2 ------- Running threads On Pid: 6362 ------- MainThread 139901706389248 True Thread-test1 139901682108160 True Checker 139901661128448 True Thread-test2 139901671618304 True Thread-test2: I am go dying. Please take care of yourself and drink more hot water! ------- Running threads On Pid: 6362 ------- MainThread 139901706389248 True Thread-test1 139901682108160 True Checker 139901661128448 True Thread-test2 139901671618304 True Thread-test2: I am go dying. Please take care of yourself and drink more hot water! pid: 6362, tid: 139901682108160, tname: Thread-test1 ------- Running threads On Pid: 6362 ------- MainThread 139901706389248 True Thread-test1 139901682108160 True Checker 139901661128448 True // Thread-test2 已经不在了Nach einer Operation, obwohl wir
so behandeln, kümmert es uns immer noch: Thread-test2Trink mehr heißes Wasser,
Wir können Threads nicht direkt wie das Töten von Prozessen durch Signale töten, da das Töten unsere Erwartungen nur durch den Umgang mit Prozessen erfüllen kann, aber es ist offensichtlich nicht möglich, mit Threads umzugehen, egal welcher Thread getötet wird, der gesamte Prozess wird verschwinden!
Und aufgrund der GIL denken viele Kinder, dass Pythons Threads von Python selbst implementiert werden und eigentlich nicht existieren. Python sollte sie direkt zerstören können, oder?
Tatsächlich sind Pythons Threads jedoch echte Threads!
Was bedeutet das? Python-Threads sind native Threads, die vom Betriebssystem über pthread erstellt werden. Python verwendet GIL nur, um diese Threads einzuschränken, um zu entscheiden, wann mit der Planung begonnen werden soll. Nach der Ausführung einer Reihe von Anweisungen wird die GIL übergeben. Es hängt vom Betriebssystem ab, wer den Oiran gewinnt.
Wenn es sich um einen einfachen Thread handelt, verfügt das System tatsächlich über eine Möglichkeit, ihn zu beenden, z. B.: pthread_exit, pthread_kill oder pthread_cancel Weitere Informationen finden Sie unter: https://www. cnblogs.com/Creat ..
Schade: Es gibt keine Kapselung dieser Methoden auf Python-Ebene! Oh mein Gott, so wütend! Vielleicht denken die Leute, dass Threads sanft behandelt werden sollten.
So verlassen Sie einen Thread sanft
Wenn Sie einen Thread sanft verlassen möchten, ist das fast Unsinn~
Entweder nach dem Ausführen beenden oder das Flag-Bit setzen und Überprüfen Sie das Flag-Bit regelmäßig. Wenn Sie beenden müssen, beenden Sie es einfach.
Erweiterung
„So beenden Sie einen laufenden untergeordneten Thread korrekt“: https://www.cnblogs.com/Creat...
„Zerstören Sie Python-Threads nicht grob“ ：http://xiaorui.cc/2017/02/22/...
Begrüßen Sie alle Experten zur Beratung und zum Austausch, QQ-Diskussionsgruppe: 258498217
Bitte beachten Sie für den Nachdruck die Ming-Quelle: https://segmentfault.com/a/11...
Detaillierte Einführung in die Positionierung und Zerstörung in Python-Threads (mit Beispielen)
Gepostet vor 3 Tagen
Python: Positionierung und Zerstörung von Threads
c
Linux-
266 mal gelesen Das Lesen dauert 30 Minuten
HintergrundBevor ich mit der Arbeit begann, hatte ich das Gefühl, dass etwas nicht stimmte und ich hatte das Gefühl, ich würde die Schuld auf mich nehmen. Nein, es ist der dritte Arbeitstag, der mir ein schlechtes Gewissen macht. Wir haben ein erstaunliches Hintergrundprogramm, das Module dynamisch laden und in einem Thread ausführen kann. Auf diese Weise werden die Funktionen des Plug-Ins realisiert. Wenn das Modul aktualisiert wird, wird das Hintergrundprogramm selbst nicht beendet. Es wird nur der dem Modul entsprechende Thread geschlossen, der Code aktualisiert und dann gestartet. Also habe ich ein Modul geschrieben, um meine Fähigkeiten unter Beweis zu stellen, aber ich habe vergessen, die Exit-Funktion zu schreiben, was dazu führte, dass bei jeder Aktualisierung des Moduls ein neuer Thread erstellt wurde, sofern das Programm nicht neu gestartet wurde am Leben bleiben. Das ist nicht möglich, wir müssen einen Weg finden, es aufzuräumen, sonst fürchte ich, dass es explodiert. Wie reinigt man es? Mir fallen nur zwei Schritte ein:
Finde die Thread-Nummer heraus, die bereinigt werden muss
Zerstöre sie
Thread-ID herausfindenÄhnlich wie bei der üblichen Fehlerbehebung überprüfen Sie zunächst den Thread-Status des Zielprozesses über den Befehl ps, da der Thread-Name von festgelegt wurde setName, also sollte es normalerweise so sein. Ich habe den entsprechenden Thread gesehen. Verwenden Sie direkt den folgenden Code, um diesen Thread zu simulieren: Python-Version von Multithreading#coding: utf8 import threading import os import time def tt(): info = threading.currentThread() while True: print 'pid: ', os.getpid() print info.name, info.ident time.sleep(3) t1 = threading.Thread(target=tt) t1.setName('OOOOOPPPPP') t1.setDaemon(True) t1.start() t2 = threading.Thread(target=tt) t2.setName('EEEEEEEEE') t2.setDaemon(True) t2.start() t1.join() t2.join()Ausgabe:- Sie können sehen, dass der in Python ausgegebene Thread-Name was ist Das haben wir eingestellt, aber das Ergebnis von Ps lässt mich am Leben zweifeln:
root@10-46-33-56:~# ps -Tp 5613 PID SPID TTY TIME CMD 5613 5613 pts/2 00:00:00 python 5613 5614 pts/2 00:00:00 python 5613 5615 pts/2 00:00:00 python
Normalerweise sollte es nicht so sein. Habe ich mich die ganze Zeit falsch daran erinnert? Verwenden Sie zum Testen eine andere Sprachversion von Multithreading: - C-Version von Multithreading
#include<stdio.h> #include<sys> #include<sys> #include<pthread.h> void *test(void *name) { pid_t pid, tid; pid = getpid(); tid = syscall(__NR_gettid); char *tname = (char *)name; // 设置线程名字 prctl(PR_SET_NAME, tname); while(1) { printf("pid: %d, thread_id: %u, t_name: %s\n", pid, tid, tname); sleep(3); } } int main() { pthread_t t1, t2; void *ret; pthread_create(&t1, NULL, test, (void *)"Love_test_1"); pthread_create(&t2, NULL, test, (void *)"Love_test_2"); pthread_join(t1, &ret); pthread_join(t2, &ret); }</pthread.h></sys></sys></stdio.h>Ausgabe:
root@10-46-33-56:~# python t.py pid: 5613 OOOOOPPPPP 139693508122368 pid: 5613 EEEEEEEEE 139693497632512 ...
root@10-46-33-56:~# gcc t.c -lpthread && ./a.out pid: 5575, thread_id: 5577, t_name: Love_test_2 pid: 5575, thread_id: 5576, t_name: Love_test_1 pid: 5575, thread_id: 5577, t_name: Love_test_2 pid: 5575, thread_id: 5576, t_name: Love_test_1 ...
Das ist richtig, der Threadname ist tatsächlich über PS zu sehen! Aber warum kann ich die Python-Version nicht sehen? Da der Thread-Name durchroot@10-46-33-56:~# ps -Tp 5575 PID SPID TTY TIME CMD 5575 5575 pts/2 00:00:00 a.out 5575 5576 pts/2 00:00:00 Love_test_1 5575 5577 pts/2 00:00:00 Love_test_2
festgelegt wird, werfen wir einen Blick auf die Definition:
[threading.py] class Thread(_Verbose): ... @property def name(self): """A string used for identification purposes only. It has no semantics. Multiple threads may be given the same name. The initial name is set by the constructor. """ assert self.__initialized, "Thread.__init__() not called" return self.__name @name.setter def name(self, name): assert self.__initialized, "Thread.__init__() not called" self.__name = str(name) def setName(self, name): self.name = name ...
Was Sie hier sehen, ist, dass es nur die Eigenschaften des
-Objekts festlegt und es nicht berührt hat die Grundlagen, also muss es so sein, dass ich es nicht sehen kann~Es scheint, dass wir nicht mehr extern mit Mitteln wieoder
nach Python-Thread-Namen suchen können, also können wir nur lösen es in Python. Die Frage lautet also: Wie bekomme ich alle laufenden Threads in Python?kann dieses Problem perfekt lösen! Warum?
Weil es im Dokument der Funktion unten klar angegeben ist, dass alle aktiven
Thread-Objektezurückgegeben werden, mit Ausnahme beendeter und nicht gestarteter Objekte.
setName[threading.py] def enumerate(): """Return a list of all Thread objects currently alive. The list includes daemonic threads, dummy thread objects created by current_thread(), and the main thread. It excludes terminated threads and threads that have not yet been started. """ with _active_limbo_lock: return _active.values() + _limbo.values()
Da wir das Thread-Objekt erhalten, können wir dadurch die Informationen zum Thread erhalten!ThreadBitte sehen Sie sich das vollständige Codebeispiel an:#coding: utf8 import threading import os import time def get_thread(): pid = os.getpid() while True: ts = threading.enumerate() print '------- Running threads On Pid: %d -------' % pid for t in ts: print t.name, t.ident print time.sleep(1) def tt(): info = threading.currentThread() pid = os.getpid() while True: print 'pid: {}, tid: {}, tname: {}'.format(pid, info.name, info.ident) time.sleep(3) return t1 = threading.Thread(target=tt) t1.setName('Thread-test1') t1.setDaemon(True) t1.start() t2 = threading.Thread(target=tt) t2.setName('Thread-test2') t2.setDaemon(True) t2.start() t3 = threading.Thread(target=get_thread) t3.setName('Checker') t3.setDaemon(True) t3.start() t1.join() t2.join() t3.join()Ausgabe:
psroot@10-46-33-56:~# python t_show.py pid: 6258, tid: Thread-test1, tname: 139907597162240 pid: 6258, tid: Thread-test2, tname: 139907586672384 ------- Running threads On Pid: 6258 ------- MainThread 139907616806656 Thread-test1 139907597162240 Checker 139907576182528 Thread-test2 139907586672384 ------- Running threads On Pid: 6258 ------- MainThread 139907616806656 Thread-test1 139907597162240 Checker 139907576182528 Thread-test2 139907586672384 ------- Running threads On Pid: 6258 ------- MainThread 139907616806656 Thread-test1 139907597162240 Checker 139907576182528 Thread-test2 139907586672384 ------- Running threads On Pid: 6258 ------- MainThread 139907616806656 Checker 139907576182528 ...
/proc/Der Code sieht etwas lang aus, aber die Logik ist recht einfach, sowohl als auchwerden ausgedruckt Die aktuelle PID, Thread-ID und Thread-Name, und dann nach 3 Sekunden beenden Dies dient dazu, das normale Beenden des Threads zu simulieren.
Und der
aus.threading.enumerate-Thread gibt jede Sekunde alle aktiven Threads im aktuellen Prozess bisEs ist deutlich zu erkennen, dass die Informationen von und
am Anfang sichtbar sind. Beim Verlassen sind nur nochund
selbst übrig. Zerstöre den angegebenen ThreadDa wir nun den Namen und die Thread-ID erhalten, können wir auch den angegebenen Thread beenden!Thread-test1Angenommen,Thread-test2ist schwarz geworden und verrückt geworden und wir müssen es stoppen. Dann können wir es auf diese Weise lösen:Basierend auf dem obigen Code hinzufügen und ergänzen Der folgende Code:
Checkerdef _async_raise(tid, exctype): """raises the exception, performs cleanup if needed""" tid = ctypes.c_long(tid) if not inspect.isclass(exctype): exctype = type(exctype) res = ctypes.pythonapi.PyThreadState_SetAsyncExc(tid, ctypes.py_object(exctype)) if res == 0: raise ValueError("invalid thread id") elif res != 1: ctypes.pythonapi.PyThreadState_SetAsyncExc(tid, None) raise SystemError("PyThreadState_SetAsyncExc failed") def stop_thread(thread): _async_raise(thread.ident, SystemExit) def get_thread(): pid = os.getpid() while True: ts = threading.enumerate() print '------- Running threads On Pid: %d -------' % pid for t in ts: print t.name, t.ident, t.is_alive() if t.name == 'Thread-test2': print 'I am go dying! Please take care of yourself and drink more hot water!' stop_thread(t) print time.sleep(1)threading.enumerateAusgaberoot@10-46-33-56:~# python t_show.py pid: 6362, tid: 139901682108160, tname: Thread-test1 pid: 6362, tid: 139901671618304, tname: Thread-test2 ------- Running threads On Pid: 6362 ------- MainThread 139901706389248 True Thread-test1 139901682108160 True Checker 139901661128448 True Thread-test2 139901671618304 True Thread-test2: I am go dying. Please take care of yourself and drink more hot water! ------- Running threads On Pid: 6362 ------- MainThread 139901706389248 True Thread-test1 139901682108160 True Checker 139901661128448 True Thread-test2 139901671618304 True Thread-test2: I am go dying. Please take care of yourself and drink more hot water! pid: 6362, tid: 139901682108160, tname: Thread-test1 ------- Running threads On Pid: 6362 ------- MainThread 139901706389248 True Thread-test1 139901682108160 True Checker 139901661128448 True // Thread-test2 已经不在了
Nach einer Operation, obwohl wir
PS: Heißes Wasser ist zwar gut, aber acht Tassen reichen aus, also seien Sie bitte nicht gierig.Thread-test1so behandeln, kümmert es uns immer noch:Thread-test2Trink mehr heißes WasserMainThread,CheckerZurück zur Hauptgeschichte: Die obige Methode ist äußerst grob.
Denn sein Prinzip ist: Verwenden Sie die integrierte Python-API, um eine Ausnahme für den angegebenen Thread auszulösen, sodass dieser automatisch beendet werden kann
Verwenden Sie diese Methode nicht als letzten Ausweg, da eine gewisse Wahrscheinlichkeit besteht, dass sie unbeschreibliche Probleme auslöst. Erinnern! Fragen Sie mich nicht, warum ich das weiß...
Warum ist es so schwierig, einen Thread zu stoppen?
Multithreading selbst ist für die kollaborative Parallelität im Rahmen des Prozesses konzipiert Die Threads teilen sich die Ressourcen, daher gibt es viele Sperrmechanismen und Zustandskontrollen.
Wenn Sie Threads gewaltsam beenden, besteht eine hohe Wahrscheinlichkeit, dass unerwartete Fehler auftreten. Und die wichtigste Sperrressourcenfreigabe kann auch unerwartete Probleme verursachen.
Wir können Threads nicht direkt wie das Töten von Prozessen durch Signale töten, da das Töten unsere Erwartungen nur durch den Umgang mit Prozessen erfüllen kann, aber es ist offensichtlich nicht möglich, mit Threads umzugehen, egal welcher Thread getötet wird. Der gesamte Prozess wird beendet!
Und aufgrund der GIL denken viele Kinder, dass Pythons Threads von Python selbst implementiert werden und eigentlich nicht existieren. Python sollte sie direkt zerstören können, oder?
Tatsächlich sind Pythons Threads jedoch echte Threads!
Was bedeutet das? Python-Threads sind native Threads, die vom Betriebssystem über pthread erstellt werden. Python verwendet GIL nur, um diese Threads einzuschränken, um zu entscheiden, wann mit der Planung begonnen werden soll. Nach der Ausführung einer Reihe von Anweisungen wird die GIL übergeben. Wer den Oiran gewinnt, hängt vom Betriebssystem ab.
Wenn es sich um einen einfachen Thread handelt, verfügt das System tatsächlich über eine Möglichkeit, ihn zu beenden, z. B.:
pthread_exit,pthread_killoderpthread_cancelWeitere Informationen finden Sie unter: https://www. cnblogs.com/Creat ..Schade: Es gibt keine Kapselung dieser Methoden auf Python-Ebene! Oh mein Gott, so wütend! Vielleicht denken die Leute, dass Threads sanft behandelt werden sollten.
So verlassen Sie einen Thread sanft
Wenn Sie einen Thread sanft verlassen möchten, ist das fast Unsinn~
Entweder nach dem Ausführen beenden oder das Flag-Bit setzen und Überprüfen Sie das Flag-Bit regelmäßig. Wenn Sie beenden müssen, beenden Sie es einfach.
Erweiterung
„So beenden Sie einen laufenden untergeordneten Thread korrekt“: https://www.cnblogs.com/Creat...
„Zerstören Sie Python-Threads nicht grob“ ：http://xiaorui.cc/2017/02/22/...Begrüßen Sie alle Experten zur Beratung und zum Austausch, QQ-Diskussionsgruppe: 258498217
Bitte beachten Sie für den Nachdruck die Ming-Quelle: https://segmentfault.com/a/11...Alle Rechte vorbehalten
-
Wenn Sie der Meinung sind, dass mein Artikel für Sie nützlich ist, können Sie ihn gerne loben
Vielleicht haben Sie Interesse
2 Kommentare Zeitliche Sortierung >
Wenn ich es wäre, würde ich vielleicht -9 töten, ich würde lieber aus Versehen tausend töten, als einen gehen zu lassen, Muschel
Antworten Nein ~ -9 sind dabei gestorben ~
- Sie können sehen, dass der in Python ausgegebene Thread-Name was ist Das haben wir eingestellt, aber das Ergebnis von Ps lässt mich am Leben zweifeln:
Das obige ist der detaillierte Inhalt vonDetaillierte Einführung in die Positionierung und Zerstörung in Python-Threads (mit Beispielen). Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!