Exemple de Java implémentant le verrouillage distribué Redisson

Cet article présente principalement le redisson de programmation Java pour implémenter des exemples de codes de verrouillage distribués. L'éditeur pense que c'est plutôt bien, je vais le partager avec vous ici pour référence des amis dans le besoin.

En raison de mon travail très occupé récemment, je n'ai pas mis à jour mon blog depuis longtemps. Aujourd'hui, je vous propose un article sur l'implémentation des verrous distribués par Redisson. Eh bien, sans plus tarder, passons directement à l'action. le sujet.

1. Reentrant Lock

L'objet Java RLock de verrouillage réentrant distribué de Redisson implémente java.util.concurrent L'interface locks.Lock prend également en charge l'expiration et le déverrouillage automatiques. .

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 fournit également des méthodes liées à l'exécution asynchrone pour les verrous distribués :

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. Fair Lock

Le verrouillage équitable réentrant distribué Redisson est également un objet RLock qui implémente l'interface java.util.concurrent.locks.Lock . Tout en fournissant la fonction de déverrouillage automatique de l'expiration, il garantit également que lorsque plusieurs threads clients Redisson demandent des verrous en même temps, la priorité est donnée au thread qui effectue la demande en premier.

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 fournit également des méthodes d'exécution asynchrones pour les verrous équitables réentrants distribués :

RLock fairLock = redisson.getFairLock("anyLock"); 
fairLock.lockAsync(); 
fairLock.lockAsync(10, TimeUnit.SECONDS); 
Future<Boolean> res = fairLock.tryLockAsync(100, 10, TimeUnit.SECONDS);

3. Interlock (MultiLock)

L'objet RedissonMultiLock de Redisson peut associer plusieurs objets RLock dans un verrouillage, et chaque instance d'objet RLock peut provenir de différentes instances de Redisson.

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. Red Lock (RedLock)

L'objet RedissonRedLock de Redisson implémente l'ajout introduit par le verrouillage Redlock. algorithme. Cet objet peut également être utilisé pour associer plusieurs objets RLock en tant que verrou rouge. Chaque instance d'objet RLock peut provenir d'une instance Redisson différente.

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. ReadWriteLock (ReadWriteLock)

Verrou de lecture et d'écriture réentrant distribué de Redisson RReadWriteLock, objet Java implémente l'interface java.util.concurrent.locks.ReadWriteLock. Il prend également en charge le déverrouillage automatique après expiration. Cet objet autorise plusieurs verrous en lecture en même temps, mais peut avoir au plus un verrou en écriture.

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. Sémaphore (Semaphore)

Sémaphore distribué de Redisson (Semaphore) Java L'objet RSemaphore adopte une interface et une utilisation similaires à 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. Sémaphore expirable (PermitExpirableSemaphore)

Le sémaphore expirable de Redisson (PermitExpirableSemaphore) ajoute un délai d'expiration. à chaque signal basé sur l'objet RSemaphore. Chaque signal peut être identifié par un identifiant indépendant, et il ne peut être émis qu'en soumettant cet identifiant.

RPermitExpirableSemaphore semaphore = redisson.getPermitExpirableSemaphore("mySemaphore"); 
String permitId = semaphore.acquire(); 
// 获取一个信号，有效期只有2秒钟。 
String permitId = semaphore.acquire(2, TimeUnit.SECONDS); 
// ... 
semaphore.release(permitId);

8. Verrouillage (CountDownLatch)

Objet Java de verrouillage distribué (CountDownLatch) RCountDownLatch Adopte un interface et utilisation similaires à java.util.concurrent.CountDownLatch.

RCountDownLatch latch = redisson.getCountDownLatch("anyCountDownLatch"); 
latch.trySetCount(1); 
latch.await(); 
// 在其他线程或其他JVM里 
RCountDownLatch latch = redisson.getCountDownLatch("anyCountDownLatch"); 
latch.countDown();

Résumé

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!