règles de bloc/méthode et de programmation synchronisées dans la concurrence java

Question

Je suis intéressé par les règles de bloc et de programmation synchronisées. Je sais que les deux méthodes sont utilisées pour garantir des données synchrones. Mais je ne les comprends pas, comment ils fonctionnent. Quels sont les avantages et les inconvénients des règles synchronisées et d'ordonnancement? Je referd l'instruction sur les règles d'ordonnancement ici: http://help.eclipse.org/mars/index.jsp?topic=%2Forg.eclipse.platform.doc.isv%2Fguide%2Fruntime_jobs_rules.htm Dans ce document, il représentait environ une règle ci-dessous:

We can fix this example by creating a simple scheduling rule that acts as a mutex (also known as a binary semaphore): 

    class Mutex implements ISchedulingRule { 
     public boolean isConflicting(ISchedulingRule rule) { 
     return rule == this; 
     } 
     public boolean contains(ISchedulingRule rule) { 
     return rule == this; 
     } } 

Ensuite, la règle est définie dans un objet ou une méthode pour contrôler l'emploi. Dans ce code, je ne vois pas la règle ainsi que la façon de vérifier la règle. Et quand la règle de planification ou synchronisée est-elle utilisée?

Remerciez dans le calendrier et la synchronisation avance

Answer 1

sont utilisés lorsque les discussions ont besoin d'accéder aux mêmes données. Ce serait un problème majeur si un thread lit des données, le mute, et avant qu'il puisse écrire les données, un autre thread lit les données.

Cette section doit être soigneusement vérifiée pour garantir qu'un seul processus peut accéder à la ressource partagée à la fois. La synchronisation ne permet qu'un seul processus à la fois d'utiliser la ressource (de manière plus avancée, la synchronisation peut autoriser un nombre prédéterminé d'accès multiples si elle est inclinée, c.-à-d. Sémaphores)

L'horaire est utilisé pour indiquer quel ordre les threads peuvent accéder (synchroniser) la ressource partagée.

Si un thread n'a pas accès à une ressource qu'un autre thread serait, il n'y a aucune raison de vous soucier de la synchronisation car il est le seul à utiliser cette ressource

spécifique à l'extrait de code, il crée un mutex (ce qui est clairement indiqué) qui permet l'accès de la ressource à un seul processus - la note ci-dessus l'appelle un sémaphore binaire, et à toutes fins utiles, cela fonctionne comme un seul. Cependant, java utilise des moniteurs dans leurs verrous de mutex prédéfinis; pas de sémaphores.