Beispiel für die Implementierung einer verteilten Redisson-Sperre in Java

Dieser Artikel stellt hauptsächlich Java-Programmier-Redisson zur Implementierung verteilter Sperrcode-Beispiele vor. Ich werde ihn hier als Referenz für bedürftige Freunde teilen.

Da ich in letzter Zeit sehr beschäftigt war, habe ich meinen Blog schon lange nicht mehr aktualisiert. Heute bringe ich Ihnen einen Artikel über die Implementierung verteilter Sperren in Redisson. Okay, los geht's direkt zum Thema.

1. Reentrant Lock

Redissons verteiltes Reentrant Lock RLock Java-Objekt implementiert java.util.concurrent. Die locks.Lock-Schnittstelle unterstützt auch den automatischen Ablauf und das Entsperren .

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 bietet auch asynchrone ausführungsbezogene Methoden für verteilte Sperren:

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

Redisson Distributed Reentrant Fair Lock ist auch ein RLock-Objekt, das die java.util.concurrent.locks.Lock-Schnittstelle implementiert. Während die Funktion zum automatischen Entsperren des Ablaufs bereitgestellt wird, wird auch sichergestellt, dass bei gleichzeitiger Anforderung von Sperren durch mehrere Redisson-Client-Threads dem Thread Priorität eingeräumt wird, der die Anforderung zuerst stellt.

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 bietet auch asynchrone Ausführungsmethoden für verteilte wiedereintrittsfähige faire Sperren:

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

3. Interlock (MultiLock)

Das RedissonMultiLock-Objekt kann mehrere RLock-Objekte zu einem Interlock verknüpfen, und jede RLock-Objektinstanz kann aus verschiedenen Redisson-Instanzen stammen.

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)

Das RedissonRedLock-Objekt implementiert den durch die Redlock-Sperre eingeführten Zusatz Algorithmus. Dieses Objekt kann auch verwendet werden, um mehrere RLock-Objekte als rote Sperre zuzuordnen. Jede RLock-Objektinstanz kann von einer anderen Redisson-Instanz stammen.

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)

Redissons verteilte wiedereintrittsfähige Lese- und Schreibsperre RReadWriteLock, das Java Das Objekt implementiert die java.util.concurrent.locks.ReadWriteLock-Schnittstelle. Es unterstützt auch die automatische Entsperrung nach Ablauf. Dieses Objekt ermöglicht mehrere Lesesperren gleichzeitig, kann jedoch höchstens eine Schreibsperre haben.

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

Redissons verteiltes Semaphor (Semaphore) Java Das Objekt, das RSemaphore übernimmt eine Schnittstelle und Verwendung ähnlich wie 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. Ablaufendes Semaphor (PermitExpirableSemaphore)

Redissons abgelaufenes Semaphor (PermitExpirableSemaphore) fügt eine Ablaufzeit hinzu zu jedem Signal basierend auf dem RSemaphore-Objekt. Jedes Signal ist durch eine eigenständige ID identifizierbar und kann nur durch Übermittlung dieser ID freigegeben werden.

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

8. Sperren (CountDownLatch)

Redissons verteiltes Sperren (CountDownLatch) Java-Objekt RCountDownLatch Nimmt an Schnittstelle und Verwendung ähnlich wie java.util.concurrent.CountDownLatch.

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

Zusammenfassung

Das obige ist der detaillierte Inhalt vonBeispiel für die Implementierung einer verteilten Redisson-Sperre in Java. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!