Sortierung von Python-Threads

Threads haben fünf Zustände

Neu, bereit, läuft, blockiert und tot.

Es gibt drei Blockierungssituationen:

Synchronisierte Blockierung bezieht sich auf den Status konkurrierender Sperren. Der Thread wechselt in diesen Status, wenn die Sperre angefordert wird, und kehrt in den laufenden Status zurück Sobald die Sperre erfolgreich erhalten wurde, bezieht sich die Warteblockierung auf den Status des Wartens auf Benachrichtigungen von anderen Threads. Nachdem der Thread die bedingte Sperre erhalten hat, wird dieser Status aktiviert, sobald andere Threads Benachrichtigungen senden. Der Thread tritt in den synchronen Blockierungszustand ein und konkurriert erneut um die bedingte Sperre.

Andere Blockierung bezieht sich auf die Blockierung beim Aufrufen von time.sleep(), anotherthread.join() oder beim Warten auf IO Der Thread gibt die erworbene Sperre nicht frei.

Python bietet zwei Möglichkeiten, Threads zu verwenden: eine ist funktional und die andere ist Klassenpaketierung.

* Thread
* Threading

1. Thread:

thread.start_new_thread ( function , args [ , kwargs ] )

>>> import thread
>>> dir(thread)
['LockType', '__doc__', '__name__', '__package__', '_count', '_local', 'allocate', 'allocate_lock', 'error', 'exit', 'exit_thread', 'get_ident', 'interrupt_main', 'stack_size', 'start_new', 'start_new_thread']

Rufen Sie den Thread auf Modul Die start_new_thread()-Funktion zum Generieren eines neuen Threads.

2. Threading:

>>> import threading
>>> dir(threading)
['BoundedSemaphore', 'Condition', 'Event', 'Lock', 'RLock', 'Semaphore', 'Thread', 'ThreadError', 'Timer', '_BoundedSemaphore', '_Condition', '_DummyThread', '_Event', '_MainThread', '_RLock', '_Semaphore', '_Timer', '_VERBOSE', '_Verbose', '__all__', '__builtins__', '__doc__', '__file__', '__name__', '__package__', '_active', '_active_limbo_lock', '_after_fork', '_allocate_lock', '_counter', '_enumerate', '_format_exc', '_get_ident', '_limbo', '_newname', '_pickSomeNonDaemonThread', '_profile_hook', '_shutdown', '_sleep', '_start_new_thread', '_sys', '_test', '_time', '_trace_hook', 'activeCount', 'active_count', 'currentThread', 'current_thread', 'deque', 'enumerate', 'local', 'setprofile', 'settrace', 'stack_size', 'warnings']

Gemeinsame Methoden, die vom Threading-Modul bereitgestellt werden:

>>> dir(threading.Thread)
['_Thread__bootstrap', '_Thread__bootstrap_inner', '_Thread__delete', '_Thread__exc_clear', '_Thread__exc_info', '_Thread__initialized', '_Thread__stop', '__class__', '__delattr__', '__dict__', '__doc__', '__format__', '__getattribute__', '__hash__', '__init__', '__module__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', '_block', '_note', '_reset_internal_locks', '_set_daemon', '_set_ident', 'daemon', 'getName', 'ident', 'isAlive', 'isDaemon', 'is_alive', 'join', 'name', 'run', 'setDaemon', 'setName', 'start']

threading.currentThread(): Gibt die aktuelle Thread-Variable zurück .

threading.enumerate(): Gibt eine Liste mit laufenden Threads zurück. „Laufen“ bezieht sich auf den Thread nach dem Start und vor dem Ende, mit Ausnahme von Threads vor dem Start und nach der Beendigung.

threading.activeCount(): Gibt die Anzahl der laufenden Threads zurück, was das gleiche Ergebnis wie len(threading.enumerate()) hat.

Erben Sie die threading.Thread-Methode und überschreiben Sie die run-Methode.

Prototyp der Initialisierungsfunktion der Threading.Thread-Klasse: def __init__(self, group=None, target=None, name=None, args=(), kwargs={})
Die Parametergruppe ist reserviert für zukünftige Erweiterungen;
Das Parameterziel ist ein aufrufbares Objekt (auch Aktivität [Aktivität] genannt), das nach dem Start des Threads ausgeführt wird.
Der Parametername ist der Name des Threads. Der Standardwert ist „Thread-N“, wobei N eine Zahl ist.
Die Parameter args und kwargs stellen beim Aufruf von target die Parameterliste bzw. die Schlüsselwortparameter dar.


join()-Methode, der Thread, der diese Methode aufruft, wartet, bis das Thread-Objekt abgeschlossen ist, und setzt dann die Ausführung fort.
Der Aufruf von Thread.join blockiert den aufrufenden Thread, bis der aufgerufene Thread seine Ausführung beendet oder eine Zeitüberschreitung auftritt. Der Parameter timeout ist ein numerischer Typ und gibt die Timeout-Zeit an. Wenn dieser Parameter nicht angegeben wird, wird der aufrufende Thread blockiert, bis der aufgerufene Thread endet.

threading.Lock-Objekt: Mutex, mit den Methoden acquire() und release()

RLock ermöglicht die mehrfache Erfassung im selben Thread. Aber Lock lässt dies nicht zu. Hinweis: Wenn RLock verwendet wird, müssen Acquire und Release paarweise auftreten, d. h. Acquire wird n-mal aufgerufen und Release muss n-mal aufgerufen werden, um die belegte Sperre wirklich freizugeben.

threading.Condition-Objekt: Bedingungsvariable Wenn dieses Objekt erstellt wird, enthält es ein Lock-Objekt (da die Bedingungsvariable immer zusammen mit Mutex verwendet wird). Die Methoden „acquire()“ und „release()“ können für das Condition-Objekt aufgerufen werden, um potenzielle Lock-Objekte zu steuern.



Condition.wait([timeout]): Die Wartemethode gibt den belegten internen Speicher frei und der Thread wird angehalten, bis er nach Erhalt einer Benachrichtigung geweckt wird oder eine Zeitüberschreitung (bei Zeitüberschreitung) auftritt Parameter wird mit Wörtern bereitgestellt). Wenn der Thread aufgeweckt wird und den Thread erneut belegt, wird das Programm weiter ausgeführt.

Condition.notify(): Weckt einen angehaltenen Thread auf (falls es einen angehaltenen Thread gibt). Hinweis: Die Methode notify() gibt den belegten Speicher nicht frei.

Condition.notifyAll() Weckt alle angehaltenen Threads auf (falls es angehaltene Threads gibt). Hinweis: Diese Methoden geben den belegten Speicher nicht frei.