suchen
HeimBackend-EntwicklungPython-TutorialDetaillierte Einführung in die Positionierung und Zerstörung in Python-Threads (mit Beispielen)

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:

  1. Finde die Thread-Nummer heraus, die bereinigt werden muss

  2. 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:

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 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:~# 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_2
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 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

Es scheint, dass wir nicht mehr extern mit Mitteln wie

oder ps nach Python-Thread-Namen suchen können, also können wir nur lösen es in Python. /proc/

Die Frage lautet also: Wie bekomme ich alle laufenden Threads in Python?

kann dieses Problem perfekt lösen! Warum?threading.enumerate

Weil es im Dokument der Funktion unten klar angegeben ist, dass alle aktiven

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

Und der

-Thread gibt jede Sekunde alle aktiven Threads im aktuellen Prozess bis Checker aus. threading.enumerate

Es ist deutlich zu erkennen, dass die Informationen von

und Thread-test1 am Anfang sichtbar sind. Beim Verlassen sind nur noch Thread-test2 und MainThread selbst übrig. Checker

Zerstöre den angegebenen Thread

Da wir nun den Namen und die Thread-ID erhalten, können wir auch den angegebenen Thread beenden!

Angenommen,

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

Basierend auf dem obigen Code hinzufügen und ergänzen Der folgende Code:

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,

PS: Heißes Wasser ist zwar gut, aber acht Tassen reichen aus, also seien Sie bitte nicht gierig.

Zurück zur Hauptgeschichte: Die obige Methode ist äußerst grob. Warum sagen Sie das?

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

Detaillierte Einführung in die Positionierung und Zerstörung in Python-Threads (mit Beispielen)

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 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...







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:
      root@10-46-33-56:~# python t.py
      pid:  5613
      OOOOOPPPPP 139693508122368
      pid:  5613
      EEEEEEEEE 139693497632512
      ...
    1. 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:
    2. 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:
    3. 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_2

    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 durch

    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 wie

    oder

    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-Objekte

    zurü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: ps

    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
    ...
    /proc/Der Code sieht etwas lang aus, aber die Logik ist recht einfach, sowohl als auch

    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.

    Und der threading.enumerate-Thread gibt jede Sekunde alle aktiven Threads im aktuellen Prozess bis

    aus.

    Es ist deutlich zu erkennen, dass die Informationen von und

    am Anfang sichtbar sind. Beim Verlassen sind nur noch

    und

    selbst übrig.

    Zerstöre den angegebenen Thread

    Da wir nun den Namen und die Thread-ID erhalten, können wir auch den angegebenen Thread beenden!

    Thread-test1Angenommen, Thread-test2 ist 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: Checker

    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)
    threading.enumerateAusgabe
    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 Thread-test1 so behandeln, kümmert es uns immer noch: Thread-test2Trink mehr heißes WasserMainThread, Checker

    PS: Heißes Wasser ist zwar gut, aber acht Tassen reichen aus, also seien Sie bitte nicht gierig.

    Zurü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

    Detaillierte Einführung in die Positionierung und Zerstörung in Python-Threads (mit Beispielen)

    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_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...

    • 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 ~

                                                                                                                                                                                                                                                                                                                                                                                                                               —                                                                                                                                                                                                                                                                             Autor                                                                                                                                                                                                                Antwort hinzufügenLaden...Weitere Kommentare anzeigen

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!

Stellungnahme
Dieser Artikel ist reproduziert unter:segmentfault. Bei Verstößen wenden Sie sich bitte an admin@php.cn löschen
C语言中的常量是什么,可以举一个例子吗?C语言中的常量是什么,可以举一个例子吗?Aug 28, 2023 pm 10:45 PM

常量也称为变量,一旦定义,其值在程序执行期间就不会改变。因此,我们可以将变量声明为引用固定值的常量。它也被称为文字。必须使用Const关键字来定义常量。语法C编程语言中使用的常量语法如下-consttypeVariableName;(or)consttype*VariableName;不同类型的常量在C编程语言中使用的不同类型的常量如下所示:整数常量-例如:1,0,34,4567浮点数常量-例如:0.0,156.89,23.456八进制和十六进制常量-例如:十六进制:0x2a,0xaa..八进制

VSCode和VS C++IntelliSense无法工作或拾取库VSCode和VS C++IntelliSense无法工作或拾取库Feb 29, 2024 pm 01:28 PM

VS代码和VisualStudioC++IntelliSense可能无法拾取库,尤其是在处理大型项目时。当我们将鼠标悬停在#Include<;wx/wx.h>;上时,我们看到了错误消息“CannotOpen源文件‘string.h’”(依赖于“wx/wx.h”),有时,自动完成功能无法响应。在这篇文章中,我们将看到如果VSCode和VSC++IntelliSense不能工作或不能提取库,你可以做些什么。为什么我的智能感知不能在C++中工作?处理大文件时,IntelliSense有时

修复Xbox错误代码8C230002修复Xbox错误代码8C230002Feb 27, 2024 pm 03:55 PM

您是否由于错误代码8C230002而无法在Xbox上购买或观看内容?一些用户在尝试购买或在其控制台上观看内容时不断收到此错误。抱歉,Xbox服务出现问题。稍后再试.有关此问题的帮助,请访问www.xbox.com/errorhelp。状态代码:8C230002这种错误代码通常是由于暂时的服务器或网络问题引起的。但是,还有可能是由于帐户的隐私设置或家长控制等其他原因,这些可能会阻止您购买或观看特定内容。修复Xbox错误代码8C230002如果您尝试在Xbox控制台上观看或购买内容时收到错误代码8C

递归程序在C++中找到数组的最小和最大元素递归程序在C++中找到数组的最小和最大元素Aug 31, 2023 pm 07:37 PM

我们以整数数组Arr[]作为输入。目标是使用递归方法在数组中找到最大和最小的元素。由于我们使用递归,我们将遍历整个数组,直到达到长度=1,然后返回A[0],这形成了基本情况。否则,将当前元素与当前最小或最大值进行比较,并通过递归更新其值以供后续元素使用。让我们看看这个的各种输入输出场景&minus;输入&nbsp;&minus;Arr={12,67,99,76,32};输出&nbsp;&minus;数组中的最大值:99解释&nbsp;&mi

中国东方航空宣布C919客机即将投入实际运营中国东方航空宣布C919客机即将投入实际运营May 28, 2023 pm 11:43 PM

5月25日消息,中国东方航空在业绩说明会上披露了关于C919客机的最新进展。据公司表示,与中国商飞签署的C919采购协议已于2021年3月正式生效,其中首架C919飞机已在2022年底交付。预计不久之后,该飞机将正式投入实际运营。东方航空将以上海为主要基地进行C919的商业运营,并计划在2022年和2023年引进总共5架C919客机。公司表示,未来的引进计划将根据实际运营情况和航线网络规划来确定。据小编了解,C919是中国具有完全自主知识产权的全球新一代单通道干线客机,符合国际通行的适航标准。该

C++程序打印数字的螺旋图案C++程序打印数字的螺旋图案Sep 05, 2023 pm 06:25 PM

以不同格式显示数字是学习基本编码问题之一。不同的编码概念,如条件语句和循环语句。有不同的程序中,我们使用特殊字符(如星号)来打印三角形或正方形。在本文中,我们将以螺旋形式打印数字,就像C++中的正方形一样。我们将行数n作为输入,然后从左上角开始移向右侧,然后向下,然后向左,然后向上,然后再次向右,以此类推等等。螺旋图案与数字123456724252627282982340414243309223948494431102138474645321120373635343312191817161514

C语言中的void关键字的作用C语言中的void关键字的作用Feb 19, 2024 pm 11:33 PM

C中的void是一个特殊的关键字,用来表示空类型,也就是指没有具体类型的数据。在C语言中,void通常用于以下三个方面。函数返回类型为void在C语言中,函数可以有不同的返回类型,例如int、float、char等。然而,如果函数不返回任何值,则可以将返回类型设为void。这意味着函数执行完毕后,并不返回具体的数值。例如:voidhelloWorld()

23 年来首次,C# 获得了 TIOBE 2023 年度编程语言奖23 年来首次,C# 获得了 TIOBE 2023 年度编程语言奖Jan 11, 2024 pm 04:45 PM

根据TIOBE编程社区指数,该指数是衡量编程语言受欢迎程度的标准之一,通过收集来自全球工程师、课程、供应商和搜索引擎的数据进行评估。2024年1月TIOBE指数于近日发布,同时官方公布了2023年编程语言排名,C#荣获TIOBE2023年度编程语言,这是23年来C#首次拿下这一荣誉。TIOBE官方新闻稿称,C#已经稳居前10名长达20多年,如今它正在追赶四大语言,成为一年内涨幅最大的编程语言(+1.43%),当之无愧地获得了该奖项。排名第二的是Scratch(+0.83%)和Fortran(+0

See all articles

Heiße KI -Werkzeuge

Undresser.AI Undress

Undresser.AI Undress

KI-gestützte App zum Erstellen realistischer Aktfotos

AI Clothes Remover

AI Clothes Remover

Online-KI-Tool zum Entfernen von Kleidung aus Fotos.

Undress AI Tool

Undress AI Tool

Ausziehbilder kostenlos

Clothoff.io

Clothoff.io

KI-Kleiderentferner

AI Hentai Generator

AI Hentai Generator

Erstellen Sie kostenlos Ai Hentai.

Heiße Werkzeuge

SublimeText3 Mac-Version

SublimeText3 Mac-Version

Codebearbeitungssoftware auf Gottesniveau (SublimeText3)

SAP NetWeaver Server-Adapter für Eclipse

SAP NetWeaver Server-Adapter für Eclipse

Integrieren Sie Eclipse mit dem SAP NetWeaver-Anwendungsserver.

MinGW – Minimalistisches GNU für Windows

MinGW – Minimalistisches GNU für Windows

Dieses Projekt wird derzeit auf osdn.net/projects/mingw migriert. Sie können uns dort weiterhin folgen. MinGW: Eine native Windows-Portierung der GNU Compiler Collection (GCC), frei verteilbare Importbibliotheken und Header-Dateien zum Erstellen nativer Windows-Anwendungen, einschließlich Erweiterungen der MSVC-Laufzeit zur Unterstützung der C99-Funktionalität. Die gesamte MinGW-Software kann auf 64-Bit-Windows-Plattformen ausgeführt werden.

Dreamweaver CS6

Dreamweaver CS6

Visuelle Webentwicklungstools

WebStorm-Mac-Version

WebStorm-Mac-Version

Nützliche JavaScript-Entwicklungstools