Notes d'étude JAVA (multithreading 4) - sécurité des threads 3 (mécanisme de synchronisation des threads - verrouillage)
Méthode 3 : Verrouiller (verrouiller) (ajouté après JDK5.0)
La méthode pour résoudre le problème de la sécurité des threads (mécanisme de synchronisation) - la troisième façon de réaliser la synchronisation -> Verrouiller (verrouiller)
- À partir de JDK 5.0, Java fournit un mécanisme de synchronisation de thread plus puissant - la synchronisation est obtenue en définissant explicitement un objet de verrouillage de synchronisation. Les verrous de synchronisation sont implémentés à l'aide d'objets Lock.
- L'interface java.util.concurrent.locks.Lock est un outil permettant de contrôler l'accès aux ressources partagées par plusieurs threads.
Le verrou fournit un accès exclusif aux ressources partagées. Un seul thread peut verrouiller l'objet Lock à la fois, et le thread doit obtenir l'objet Lock avant de commencer à accéder à la ressource partagée. - La classe ReentrantLock implémente Lock, qui a la même sémantique de simultanéité et de mémoire que la classe synchronized. Lors de l'implémentation d'un contrôle thread-safe, ReentrantLock est plus couramment utilisé, qui peut explicitement verrouiller et libérer des verrous.
Questions d'entretien les plus courantes : les similitudes et les différences entre synchronisé et verrouillé ?
Idem :
les deux peuvent résoudre le problème de sécurité des threads
différent :
- Le mécanisme synchronisé libère automatiquement le moniteur de synchronisation après l'exécution du code de synchronisation correspondant
- Le verrouillage doit démarrer la synchronisation manuellement (méthode lock()) et la fin de la synchronisation doit également être implémentée manuellement (méthode unLock())
Ordre de priorité suggéré pour les méthodes synchrones :
Verrouiller → bloc de code synchrone (déjà entré dans le corps de la méthode et ressources correspondantes allouées) → méthode synchrone (en dehors du corps de la méthode)
LockTest (utilisant l'implémentation de l'interface Runnable pour implémenter le mécanisme de synchronisation des threads Lock (lock))
class Windows6 implements Runnable{
private int ticket=100;
//1.实例化ReentrantLock
private ReentrantLock lock=new ReentrantLock();
@Override
public void run() {
try{
//2.调用上锁方法lock()
lock.lock();
while (true){
if (ticket>0){
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName() + "卖票，票号为：" + ticket);
ticket--;
}else {
break;
}
}
}finally {
//3.调用解锁方法unlock()
lock.unlock();
}
}
}
public class LockTest {
public static void main(String[] args) {
Windows6 windows = new Windows6();
Thread t1 = new Thread(windows);
Thread t2 = new Thread(windows);
Thread t3 = new Thread(windows);
t1.setName("窗口1");
t2.setName("窗口2");
t3.setName("窗口3");
t1.start();
t2.start();
t3.start();
}
}
LockTest1 (Utilisation de la méthode d'héritage de la classe Thread pour implémenter le mécanisme de synchronisation des threads Lock (lock))
class Windows7 extends Thread{
private static int ticket=100;
//1.实例化ReentrantLock
private static ReentrantLock lock=new ReentrantLock();
@Override
public void run() {
try{
//2.调用上锁方法lock()
lock.lock();
while (true){
if (ticket>0){
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName() + "卖票，票号为：" + ticket);
ticket--;
}else {
break;
}
}
}finally {
//3.调用解锁方法unlock()
lock.unlock();
}
}
}
public class LockTest1 {
public static void main(String[] args) {
Windows7 windows1=new Windows7();
Windows7 windows2=new Windows7();
Windows7 windows3=new Windows7();
windows1.setName("窗口1");
windows2.setName("窗口2");
windows3.setName("窗口3");
windows1.start();
windows2.start();
windows3.start();
}
}