bloquear (bloquear)
1. A partir de JDK 5.0 , Java proporciona un mecanismo de sincronización de subprocesos más potente: la sincronización se logra mediante la definición explícita de objetos de bloqueo de sincronización. Los bloqueos de sincronización se implementan mediante objetos Lock .
2. La interfaz java.util.concurrent.locks.Lock es una herramienta para controlar el acceso a recursos compartidos por varios subprocesos . El bloqueo proporciona acceso exclusivo a los recursos compartidos. Solo un subproceso puede bloquear el objeto de bloqueo a la vez, y el subproceso debe obtener el objeto de bloqueo antes de comenzar a acceder al recurso compartido .
3. La clase ReentrantLock implementa Lock , que tiene la misma simultaneidad y semántica de memoria que sincronizada Al implementar el control seguro para subprocesos, se usa más comúnmente ReentrantLock , que puede bloquear y liberar bloqueos explícitamente.
================================================== =======================
Pregunta: Crear tres ventanillas para vender boletos, con un total de 100 boletos. como ejemplo
Código con problemas de seguridad de subprocesos no resueltos:
class Window implements Runnable {
private int ticket = 100;
@Override
public void run() {
while (true) {
if (ticket > 0) {
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName() + ":售票，票号为：" + ticket);
ticket--;
} else {
break;
}
}
}
}
public class LockTest {
public static void main(String[] args) {
Window w = new Window();
Thread t1 = new Thread(w);
Thread t2 = new Thread(w);
Thread t3 = new Thread(w);
t1.setName("窗口1");
t2.setName("窗口2");
t3.setName("窗口3");
t1.start();
t2.start();
t3.start();
}
}
Los códigos anteriores darán como resultado votos pesados y votos incorrectos.
A continuación, resolvemos el problema de seguridad de los hilos mediante el método Lock lock.
bloquear (bloquear)
class A{
private final ReentrantLock lock = new ReenTrantLock();
public void m(){
lock.lock();
try{
//保证线程安全的代码;
}
finally{
lock.unlock();
}
}
}El código después de usar el método de bloqueo de bloqueo para resolver el problema de seguridad de subprocesos es el siguiente:
class Window implements Runnable {
private int ticket = 100;
//1.实例化ReentrantLock
private ReentrantLock lock = new ReentrantLock();
@Override
public void run() {
while (true) {
try {
//2.调用锁定方法lock()
lock.lock();
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) {
Window w = new Window();
Thread t1 = new Thread(w);
Thread t2 = new Thread(w);
Thread t3 = new Thread(w);
t1.setName("窗口1");
t2.setName("窗口2");
t3.setName("窗口3");
t1.start();
t2.start();
t3.start();
}
}
================================================== == ===========================
Sincronizado vs Bloqueo
1. El bloqueo es un bloqueo explícito (abra y cierre el bloqueo manualmente, no olvide cerrar el bloqueo), sincronizado es un bloqueo implícito y se libera automáticamente cuando sale del alcance
2. El bloqueo solo tiene bloqueos de bloque de código, sincronizado tiene bloqueos de bloque de código y bloqueos de método
3. Usando el bloqueo Lock, la JVM pasará menos tiempo programando subprocesos y tendrá un mejor rendimiento. Y tiene mejor extensibilidad (proporcionar más subclases)
Orden de preferencia:
Bloquear -> Bloque de código de sincronización (ha ingresado al cuerpo del método, asignado los recursos correspondientes) -> Método de sincronización (fuera del cuerpo del método)
¡gracias por ver! ! !