Quelqu'un peut-il expliquer l'énoncé ... "La méthode statique synchronisée et la méthode synchronisée non statique ne se bloqueront pas les uns des autres - peut fonctionner en même temps"
3 Réponses :
Les objets de verrouillage sont différents sur la méthode statique et la méthode non statique. La méthode statique utilise l'objet de classe comme verrouillage (verrouiller obj: myClass.class ), tandis que la méthode non statique utilise l'objet d'instance comme verrou sur lequel l'invocation de la méthode à ce moment-là est lié (verrouiller obj: ceci ).
Je l'ai eu ce que tu as dit mais pouvez-vous expliquer plus qui concerne exactement cette déclaration.So que ce sera clair pour moi
Ils peuvent tous les deux courir dans différents fils en même temps que les objets de verrouillage sont différents. La sécurité du fil est normalement assurée en utilisant le même objet de verrouillage dans des threads différents pour effectuer l'exécution d'un morceau de code entre ces threads mutuellement exclusifs à tout moment.
Nouveau MyClass ()? déroutant imho. LOCK OBJ: Ceci.
Oui, votre verrouillage sur ceci, pas un nouvel objet.
Désolé, modifié. J'essaie juste de montrer une instance, mais "ceci" est bien meilleur :)
void test() { synchronized(this) { foo(); } }
Méthodes synchronisés non statiques Mettez le verrouillage du moniteur sur 'This'- Cela signifie que seul l'objet actuel est verrouillé.So Tous les threades associés à l'objet actuel seront bloqués pour accéder à des méthodes de synchronisation non statiques de cette classe si un thile One One One Thread méthode synchronisée. tandis que les threads d'autres objets peuvent toujours accéder aux méthodes.
et des procédés synchronisés statiques mettent le verrouillage du moniteur sur l'objet de la classe, cela signifie que si un thread de n'importe quel objet accède à la méthode que tous les objets sont bloqués pour accéder à tous les statiques. Méthodes synchronisées de la classe. P>
CLASSE PUBLIC TESTSYNC { P>
public synchronized void n1(int threadId)
{
snooze(threadId);
System.out.println("Sync non static n1 " + threadId);
}
public void n2(int threadId)
{
snooze(threadId);
System.out.println(" non static n2 " + threadId);
}
public static synchronized void s1(int threadId)
{
snooze(threadId);
System.out.println("Sync static s1 "+ threadId);
}
public static void s2(int threadId)
{
snooze(threadId);
System.out.println(" static s2 "+ threadId);
}
static void snooze(int threadId)
{
System.out.println("Waiting ... "+ threadId);
try {
Thread.sleep(10000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
public static void main(String[] args) {
TestSync ob = new TestSync();
TestSync ob2=new TestSync();
TestSync ob3=new TestSync();
TestSync ob4=new TestSync();
Runnable r1=()-> {
/*ob.n1(10);
ob.n2(10);*/
ob.s1(10);
//ob.s2(10);
};
Runnable r3=()-> {
/*ob2.n1(30);
ob2.n2(30);*/
ob2.s1(30);
//ob2.s2(30);
};
Runnable r4=()-> {
/*ob3.n1(40);
ob3.n2(40);*/
ob3.s1(30);
//ob3.s2(30);
};
Thread t1=new Thread(r1);
Thread t2= new Thread(r2);
Thread t3= new Thread(r3);
Thread t4= new Thread(r4);
Thread t5= new Thread(r5);
t1.start();
t3.start();
t4.start();
}
Dupliquer possible de Concurrence en Java: méthodes statiques synchronisées