Escribir en frente
Olvida qué grupo de amigos preguntaste antes: ¿Hay algún artículo sobre bloqueos distribuidos ~ @ 冰河? Mi respuesta es: Habrá esta semana, que también es un tema de [Alta concurrencia]. Después de pensarlo, ¿me permite publicar primero un artículo sobre cómo usar Redisson para implementar bloqueos distribuidos? Por qué ¡Porque usar Redisson para implementar bloqueos distribuidos es simple! El marco de Redisson es un bloqueo distribuido basado en Redis. Es muy potente y solo necesita ser usado. En cuanto al principio de bloqueos distribuidos, publicaré otro artículo más tarde.
El marco de Redisson es muy poderoso. Basado en el marco de Redisson, se pueden realizar casi todos los tipos de bloqueos distribuidos que se te ocurran. Aquí, enumeraré varios tipos de bloqueos distribuidos, y daré un programa de ejemplo para profundizar su comprensión. Para los detalles del principio de bloqueos distribuidos, ¡hablaremos lentamente sobre un artículo de seguimiento!
1. Bloqueo reentrante
El objeto Java de bloqueo reentrante distribuido de Redisson implementa la interfaz java.util.concurrent.locks.Lock y también admite el desbloqueo automático de caducidad.
public void testReentrantLock(RedissonClient redisson){
RLock lock = redisson.getLock("anyLock");
try{
// 1. 最常见的使用方法
//lock.lock();
// 2. 支持过期解锁功能,10秒钟以后自动解锁, 无需调用unlock方法手动解锁
//lock.lock(10, TimeUnit.SECONDS);
// 3. 尝试加锁，最多等待3秒，上锁以后10秒自动解锁
boolean res = lock.tryLock(3, 10, TimeUnit.SECONDS);
if(res){ //成功
// do your business
}
} catch (InterruptedException e) {
e.printStackTrace();
} finally {
lock.unlock();
}
}
Redisson también proporciona métodos relacionados con la ejecución asincrónica para bloqueos distribuidos:
public void testAsyncReentrantLock(RedissonClient redisson){
RLock lock = redisson.getLock("anyLock");
try{
lock.lockAsync();
lock.lockAsync(10, TimeUnit.SECONDS);
Future<Boolean> res = lock.tryLockAsync(3, 10, TimeUnit.SECONDS);
if(res.get()){
// do your business
}
} catch (InterruptedException e) {
e.printStackTrace();
} catch (ExecutionException e) {
e.printStackTrace();
} finally {
lock.unlock();
}
}
2. Bloqueo justo
El bloqueo justo reentrante distribuido de Redisson también es un objeto RLock que implementa la interfaz java.util.concurrent.locks.Lock. Si bien proporciona la función de vencimiento y desbloqueo automático, asegura que cuando múltiples hilos de cliente Redisson solicitan bloqueos al mismo tiempo, se asigna prioridad al hilo que emitió la solicitud primero.
public void testFairLock(RedissonClient redisson){
RLock fairLock = redisson.getFairLock("anyLock");
try{
// 最常见的使用方法
fairLock.lock();
// 支持过期解锁功能, 10秒钟以后自动解锁,无需调用unlock方法手动解锁
fairLock.lock(10, TimeUnit.SECONDS);
// 尝试加锁，最多等待100秒，上锁以后10秒自动解锁
boolean res = fairLock.tryLock(100, 10, TimeUnit.SECONDS);
} catch (InterruptedException e) {
e.printStackTrace();
} finally {
fairLock.unlock();
}
}
Redisson también proporciona métodos relacionados con la ejecución asincrónica para cerraduras justas reentrantes distribuidas:
RLock fairLock = redisson.getFairLock("anyLock");
fairLock.lockAsync();
fairLock.lockAsync(10, TimeUnit.SECONDS);
Future<Boolean> res = fairLock.tryLockAsync(100, 10, TimeUnit.SECONDS);
3. Enclavamiento (MultiLock)
El objeto RedissonMultiLock de Redisson puede asociar múltiples objetos RLock en un enclavamiento, y cada instancia del objeto RLock puede provenir de una instancia Redisson diferente.
public void testMultiLock(RedissonClient redisson1,RedissonClient redisson2, RedissonClient redisson3){
RLock lock1 = redisson1.getLock("lock1");
RLock lock2 = redisson2.getLock("lock2");
RLock lock3 = redisson3.getLock("lock3");
RedissonMultiLock lock = new RedissonMultiLock(lock1, lock2, lock3);
try {
// 同时加锁：lock1 lock2 lock3, 所有的锁都上锁成功才算成功。
lock.lock();
// 尝试加锁，最多等待100秒，上锁以后10秒自动解锁
boolean res = lock.tryLock(100, 10, TimeUnit.SECONDS);
} catch (InterruptedException e) {
e.printStackTrace();
} finally {
lock.unlock();
}
}
4. cerradura roja
El objeto RedissonRedLock de Redisson implementa el algoritmo de bloqueo introducido por Redlock. Este objeto también se puede usar para asociar múltiples objetos RLock en un bloqueo rojo, y cada instancia de objeto RLock puede provenir de una instancia diferente de Redisson.
public void testRedLock(RedissonClient redisson1,RedissonClient redisson2, RedissonClient redisson3){
RLock lock1 = redisson1.getLock("lock1");
RLock lock2 = redisson2.getLock("lock2");
RLock lock3 = redisson3.getLock("lock3");
RedissonRedLock lock = new RedissonRedLock(lock1, lock2, lock3);
try {
// 同时加锁：lock1 lock2 lock3, 红锁在大部分节点上加锁成功就算成功。
lock.lock();
// 尝试加锁，最多等待100秒，上锁以后10秒自动解锁
boolean res = lock.tryLock(100, 10, TimeUnit.SECONDS);
} catch (InterruptedException e) {
e.printStackTrace();
} finally {
lock.unlock();
}
}
5. Bloqueo de lectura-escritura (ReadWriteLock)
El bloqueo de lectura y escritura reentrante distribuido de Redisson RReadWriteLock, el objeto Java implementa la interfaz java.util.concurrent.locks.ReadWriteLock. También es compatible con el desbloqueo automático de caducidad. Este objeto permite múltiples bloqueos de lectura al mismo tiempo, pero como máximo un bloqueo de escritura.
RReadWriteLock rwlock = redisson.getLock("anyRWLock");
// 最常见的使用方法
rwlock.readLock().lock();
// 或
rwlock.writeLock().lock();
// 支持过期解锁功能
// 10秒钟以后自动解锁
// 无需调用unlock方法手动解锁
rwlock.readLock().lock(10, TimeUnit.SECONDS);
// 或
rwlock.writeLock().lock(10, TimeUnit.SECONDS);
// 尝试加锁，最多等待100秒，上锁以后10秒自动解锁
boolean res = rwlock.readLock().tryLock(100, 10, TimeUnit.SECONDS);
// 或
boolean res = rwlock.writeLock().tryLock(100, 10, TimeUnit.SECONDS);
...
lock.unlock();
6. Semáforo
El objeto Java de semáforo distribuido de Redisson (semáforo) RSemaphore utiliza una interfaz y un uso similar a java.util.concurrent.Semaphore.
RSemaphore semaphore = redisson.getSemaphore("semaphore");
semaphore.acquire();
//或
semaphore.acquireAsync();
semaphore.acquire(23);
semaphore.tryAcquire();
//或
semaphore.tryAcquireAsync();
semaphore.tryAcquire(23, TimeUnit.SECONDS);
//或
semaphore.tryAcquireAsync(23, TimeUnit.SECONDS);
semaphore.release(10);
semaphore.release();
//或
semaphore.releaseAsync();
7. Semáforo expirable (PermitExpirableSemaphore)
El semáforo expirable de Redisson (PermitExpirableSemaphore) se basa en el objeto RSemaphore, agregando un tiempo de vencimiento para cada señal. Cada señal puede identificarse mediante una ID independiente, y solo puede liberarse enviando esta ID cuando se libera.
RPermitExpirableSemaphore semaphore = redisson.getPermitExpirableSemaphore("mySemaphore");
String permitId = semaphore.acquire();
// 获取一个信号，有效期只有2秒钟。
String permitId = semaphore.acquire(2, TimeUnit.SECONDS);
// ...
semaphore.release(permitId);
8. Bloqueo (CountDownLatch)
El objeto Java de bloqueo distribuido de Redisson (CountDownLatch) RCountDownLatch utiliza una interfaz y un uso similar a java.util.concurrent.CountDownLatch.
RCountDownLatch latch = redisson.getCountDownLatch("anyCountDownLatch");
latch.trySetCount(1);
latch.await();
// 在其他线程或其他JVM里
RCountDownLatch latch = redisson.getCountDownLatch("anyCountDownLatch");
latch.countDown();
Escribe al final
Si el artículo le resulta útil, busque y siga la cuenta de WeChat de " Binghe Technology " en WeChat, y aprenda técnicas de programación de alta concurrencia con Binghe.
Finalmente, adjunte el mapa de conocimiento de habilidades básicas que la programación concurrente necesita dominar. Deseo que todos eviten desvíos cuando aprendan programación concurrente.
