Was beinhaltet der Multithread-Synchronisationsmechanismus?

Der Multi-Thread-Synchronisationsmechanismus umfasst: 1. Kritischer Abschnitt, der verwendet wird, um „exklusiven Besitz“ zu erreichen; 2. Semaphor, der verwendet wird, um begrenzte Ressourcen zu verfolgen; 3. Mutex, der zwischen verschiedenen Threads „exklusiver Besitz“ implementiert werden kann; Diese Threads gehören zu verschiedenen Prozessen. 4. Ereignis, das normalerweise für überlappende E/A oder zum Entwerfen einiger benutzerdefinierter Synchronisierungsobjekte verwendet wird.

Die Betriebsumgebung dieses Artikels: Windows 7-System, Dell G3-Computer.

Der Multi-Thread-Synchronisationsmechanismus umfasst:

1. Kritischer AbschnittCritical Section

Critical section（临界区）用来实现“排他性占有”。适用范围是单一进程的各线程之间。它是：

•  一个局部性对象，不是一个核心对象。

•  快速而有效率。

•  不能够同时有一个以上的 critical section 被等待。

•  无法侦测是否已被某个线程放弃。

• 可以实现线程间互斥，不能用来实现同步。

2、Semaphore

Semaphore 被用来追踪有限的资源。它是：

• 一个核心对象。

•  没有拥有者。

•  可以具名，因此可以被其他进程开启。

•  可以被任何一个线程释放（released）。

• 既能实现线程间互斥，也能实现线程间同步。

• 在跨进程中使用时，如果拥有信号量的线程意外结束，其它进程不会收到通知。

3、Mutex

Mutex 是一个核心对象，可以在不同的线程之间实现“排他性占有”，甚至即使那些线程分属不同进程。它是：

• 一个核心对象。

•  如果拥有 mutex 的那个线程结束，则会产生一个 “abandoned” 错误信息。

• i可以具名，因此可以被其他进程开启。

• 只能被拥有它的那个线程释放（released）。

• 在跨进程中使用时，如果拥有互斥器的进程意外结束，其它进程会收到一个WAIT_ABANDOEND消息。

4、Event

Event object 通常使用于 overlapped I/O，或用来设计某些自定义的同步对象。它是：

•  一个核心对象。

• 可是用来实现线程的互斥与同步。

• 可以具名，因此可以被其他进程开启。

• 在跨进程中使用时，如果拥有信号量的线程意外结束，其它进程也不会受到通知。

注意：临界区和互斥器都有“线程所有权”的概念，所以它们是不能用来实现线程间的同步的，只能用来实现互斥。原因是由于创建临界区或互斥器的线程可以不用等待LeaveCriticalSection()，SetEvent()就可以无条件进入保护的程序段，因为它拥有这个权利。另外，互斥器可以很好的处理”遗弃“操作。若线程在未释放对向象的时候就意外终止的，其它线程可以等待到一个WAIT_ABANDONED_0

Kritischer Abschnitt (kritischer Abschnitt) wird verwendet, um „exklusiven Besitz“ zu erreichen. Der Anwendungsbereich liegt zwischen Threads eines einzelnen Prozesses. Es ist:

• Ein lokales Objekt, kein Kernobjekt.

• Schnell und effizient.

• Es kann nicht auf mehrere kritische Abschnitte gleichzeitig gewartet werden.

• Es kann nicht erkannt werden, ob es von einem Thread abgebrochen wurde. 🎜
• 🎜Kann einen gegenseitigen Ausschluss zwischen Threads erreichen, kann jedoch nicht zur Synchronisierung verwendet werden. 🎜

🎜2. Semaphore🎜🎜Semaphore wird verwendet, um begrenzte Ressourcen zu verfolgen. Es ist: 🎜

• 🎜Ein Kernobjekt. 🎜
• 🎜 Kein Besitzer. 🎜
• 🎜 kann benannt werden, sodass es von anderen Prozessen geöffnet werden kann. 🎜
• 🎜 kann von jedem Thread freigegeben werden. 🎜
• 🎜Es kann den gegenseitigen Ausschluss zwischen Threads und die Synchronisierung zwischen Threads realisieren. 🎜
• 🎜Wenn bei prozessübergreifender Verwendung der Thread, der das Semaphor besitzt, unerwartet endet, werden andere Prozesse nicht benachrichtigt. 🎜

🎜3. Mutex🎜🎜Mutex ist ein Kernobjekt, das „exklusiven Besitz“ zwischen verschiedenen Threads erreichen kann, selbst wenn diese Threads zu unterschiedlichen Prozessen gehören. Es ist: 🎜

• 🎜Ein Kernobjekt. 🎜
• 🎜 Wenn der Thread, der den Mutex besitzt, endet, wird eine „abgebrochene“ Fehlermeldung generiert. 🎜
• 🎜i kann benannt werden, sodass es von anderen Prozessen geöffnet werden kann. 🎜
• 🎜 kann nur von dem Thread freigegeben werden, dem es gehört. 🎜
• 🎜Bei prozessübergreifender Verwendung erhalten andere Prozesse eine WAIT_ABANDOEND-Nachricht, wenn der Prozess, der den Mutex besitzt, unerwartet endet. 🎜

🎜4. Event🎜🎜Event-Objekt wird normalerweise für überlappende E/A oder zum Entwerfen einiger benutzerdefinierter Synchronisierungsobjekte verwendet. Es ist: 🎜

• 🎜 Ein Kernobjekt. 🎜
• 🎜Es wird verwendet, um gegenseitigen Ausschluss und Synchronisierung von Threads zu erreichen. 🎜
• 🎜kann benannt werden, sodass es von anderen Prozessen geöffnet werden kann. 🎜
• 🎜Wenn bei prozessübergreifender Verwendung der Thread, der das Semaphor besitzt, unerwartet endet, werden andere Prozesse nicht benachrichtigt. 🎜

🎜Hinweis: Kritische Abschnitte und Mutexe haben beide das Konzept des „Thread-Eigentümers“, sodass sie nicht zur Synchronisierung zwischen Threads, sondern nur zur Implementierung des gegenseitigen Ausschlusses verwendet werden können. Der Grund dafür ist, dass der Thread, der den kritischen Abschnitt oder Mutex erstellt, den geschützten Programmabschnitt bedingungslos betreten kann, ohne auf LeaveCriticalSection() und SetEvent() warten zu müssen, da er über dieses Recht verfügt. Darüber hinaus können Mutexe sehr gut mit „Abbruch“-Operationen umgehen. Wenn der Thread unerwartet beendet wird, ohne das Objekt freizugeben, können andere Threads auf einen WAIT_ABANDONED_0 warten. Aber das können weder Ereignisse noch Semaphoren. 🎜🎜Sowohl Ereignisse als auch Semaphoren können einen gegenseitigen Ausschluss und eine Synchronisierung zwischen Threads und Prozessen erreichen. 🎜🎜In Bezug auf die Nutzungseffizienz weist der kritische Abschnitt die höchste Effizienz auf, da es sich nicht um ein Kernelobjekt handelt und die anderen drei Kernobjekte sind. Sie müssen mit Hilfe des Betriebssystems implementiert werden, sodass die Effizienz relativ ist niedrig. 🎜🎜Wenn Sie es jedoch prozessübergreifend verwenden möchten, müssen Sie weiterhin Mutexe, Ereignisobjekte und Semaphoren verwenden. 🎜🎜Kurz gesagt: Versuchen Sie beim Entwerfen, nicht zuerst globale Variablen zu verwenden. Wenn nicht, ziehen Sie in Betracht, zuerst die Funktion Inter...(), dann kritische Abschnittsobjekte und schließlich Ereignisse, Mutexe und Semaphoren zu verwenden. 🎜

Das obige ist der detaillierte Inhalt vonWas beinhaltet der Multithread-Synchronisationsmechanismus?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!