En el subproceso múltiple, con el fin de garantizar la seguridad de los subprocesos, a menudo usamos sincronizado y bloqueo para la sincronización y el bloqueo de código, pero ¿cuál es la diferencia específica entre los dos y qué es adecuado para su uso en qué escenarios puede no estar claro? las diferencias son aproximadamente las siguientes:
la diferencia
1. Synchronized es una palabra clave de Java y Lock es una interfaz en Java.
2. Sincronizado liberará automáticamente el bloqueo, y el bloqueo debe liberarlo manualmente.
3. La sincronización no se puede interrumpir, el bloqueo se puede interrumpir o ininterrumpir
4. A través del bloqueo, puede saber si el hilo tiene el bloqueo, pero la sincronización no puede
5. Sincronizado puede bloquear métodos y bloques de código, mientras que Lock solo puede bloquear bloques de código
6. Lock puede usar el bloqueo de lectura para mejorar la eficiencia de la lectura de subprocesos múltiples
7. Sincronizado es un bloqueo no equitativo, ReentranLock puede controlar si es un bloqueo equitativo
Desde la interfaz de Lock, podemos ver que hay principalmente cinco métodos.Las funciones de estos métodos se pueden ver en los comentarios:
- lock (): Adquiera el candado, si el candado se usa temporalmente, espere para siempre
- desbloquear (): suelta el bloqueo
- tryLock (): tenga en cuenta que el tipo de retorno es booleano, si el bloqueo está ocupado cuando se adquiere el bloqueo, devuelve falso; de lo contrario, devuelve verdadero
- tryLock (tiempo largo, unidad TimeUnit): en comparación con tryLock (), da un límite de tiempo para garantizar el tiempo de espera del parámetro
- lockInterruptiblemente (): una forma de obtener el bloqueo, si el hilo está esperando adquirir el bloqueo para entrar al escenario, puede interrumpir este hilo, para hacer otra cosa
por las explicaciones anteriores, generalmente se puede explicar en la sección anterior, " Tipo de bloqueo (lockInterruptiblemente ()) "," estado de bloqueo (tryLock ()) "y otros problemas, así como el proceso de adquisición en la subsección anterior escribí" Es más o menos que puede intentar adquirir el bloqueo y el hilo No puedo esperar para siempre "Sí, la razón.
cerrar con llave():
public class LockTest {
private Lock lock = new ReentrantLock();
private void method(Thread thread) {
lock.lock();
try {
System.out.println(thread.getName() + " has gotten the lock!");
} catch (Exception e) {
e.printStackTrace();
} finally {
System.out.println(thread.getName() + " has unlocked the lock!");
lock.unlock();
}
}
public static void main(String[] args) {
final LockTest test = new LockTest();
Thread t1 = new Thread(new Runnable() {
@Override
public void run() {
test.method(Thread.currentThread());
}
}, "t1");
Thread t2 = new Thread(new Runnable() {
@Override
public void run() {
test.method(Thread.currentThread());
}
}, "t2");
t1.start();
t2.start();
}
}
resultado de la operación:
t1 has gotten the lock!
t1 has unlocked the lock!
t2 has gotten the lock!
t2 has unlocked the lock!
tryLock ():
public class LockTest {
private Lock lock = new ReentrantLock();
private void method(Thread thread) {
if (lock.tryLock()) {
lock.lock();
try {
System.out.println(thread.getName() + " has gotten the lock!");
} catch (Exception e) {
e.printStackTrace();
} finally {
System.out.println(thread.getName() + " has unlocked the lock!");
lock.unlock();
}
} else {
System.out.println("I'm "+thread.getName()+". Someone has gotten the lock!");
}
}
public static void main(String[] args) {
LockTest test = new LockTest();
Thread t1 = new Thread(() -> test.method(Thread.currentThread()), "t1");
Thread t2 = new Thread(new Runnable() {
@Override
public void run() {
test.method(Thread.currentThread());
}
}, "t2");
t1.start();
t2.start();
}
}
resultado de la operación:
t1 has gotten the lock!
t1 has unlocked the lock!
I'm t2. Someone has gotten the lock!
Al ver esto, creo que todos también usarán cómo usar Lock. No entraré en detalles sobre tryLock (mucho tiempo, unidad TimeUnit) y lockInterruptiblemente (). El primero tiene principalmente un tiempo de espera, y un tiempo de espera está escrito en el código de prueba. El segundo principalmente espera una interrupción y arroja una excepción de interrupción, que no se usa con frecuencia. Si le gusta explorar, puede estudiarlo usted mismo.
