Java'da Mutex var mı?

Java'da bir Mutex nesnesi veya bir tane oluşturmanın bir yolu var mı? 1 izinle başlatılan bir Semafor nesnesi bana yardımcı olmadığı için soruyorum. Şu durumu düşünün:

try {
   semaphore.acquire();
   //do stuff
   semaphore.release();
} catch (Exception e) {
   semaphore.release();
}

ilk alımda bir istisna meydana gelirse, catch bloğundaki serbest bırakma izinleri artıracak ve semafor artık bir ikili semafor değildir.

Doğru yol olacak mı?

try {
   semaphore.acquire();
   //do stuff
} catch (Exception e) {
   //exception stuff
} finally {
   semaphore.release();
}

Yukarıdaki kod semaforun ikili olmasını sağlayacak mı?

Bu sayfaya bakın: http://www.oracle.com/technetwork/articles/javase/index-140767.html

Biraz farklı bir kalıbı var ki (bence) aradığınız şey:

try {
  mutex.acquire();
  try {
    // do something
  } finally {
    mutex.release();
  }
} catch(InterruptedException ie) {
  // ...
}

Bu kullanımda, yalnızca release()başarılı biracquire()

Java'daki herhangi bir nesne bir synchronizedblok kullanılarak kilit olarak kullanılabilir . Bu ayrıca, bir istisna meydana geldiğinde otomatik olarak kilidin serbest bırakılmasını sağlayacaktır.

Object someObject = ...;

synchronized (someObject) {
  ...
}

Bununla ilgili daha fazla bilgiyi buradan okuyabilirsiniz: İçsel Kilitler ve Senkronizasyon

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;


private final Lock _mutex = new ReentrantLock(true);

_mutex.lock();

// your protected code here

_mutex.unlock();

Kimse bundan açıkça bahsetmedi, ancak bu tür bir kalıp genellikle semaforlar için uygun değildir. Bunun nedeni ise herhangi bir iş parçacığı bir semafor serbest, ancak genellikle sadece istediğiniz sahibi iplik başlangıçta kilidini muktedir kilitli . Bu kullanım durumu için Java'da genellikle şu şekilde oluşturulabilen ReentrantLocks kullanırız:

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

private final Lock lock = new ReentrantLock(true);

Ve olağan kullanım tasarım modeli şöyledir:

  lock.lock();
  try {
      // do something
  } catch (Exception e) {
      // handle the exception
  } finally {
      lock.unlock();
  }

İşte java kaynak kodunda bu kalıbı çalışırken görebileceğiniz bir örnek.

Yeniden girişli kilitlerin adaleti destekleme ek faydası vardır.

Semaforları yalnızca sahiplik bırakmayan semantiğe ihtiyacınız varsa kullanın.

Bence şunu denemelisin:

Semafor başlatılırken:

Semaphore semaphore = new Semaphore(1, true);

Ve senin içinde Runnable Implementation

try 
{
   semaphore.acquire(1);
   // do stuff

} 
catch (Exception e) 
{
// Logging
}
finally
{
   semaphore.release(1);
}

Orijinal gönderideki hata, try döngüsü içinde Acire () çağrı kümesidir. "İkili" semafor (Mutex) kullanmak için doğru bir yaklaşım:

semaphore.acquire();
try {
   //do stuff
} catch (Exception e) {
   //exception stuff
} finally {
   semaphore.release();
}

SemaphoreA'nın ikili olduğundan emin olmak için, semaforu oluştururken izin sayısını 1 olarak aktardığınızdan emin olmanız yeterlidir. Javadocs biraz daha açıklama var.

Her nesnenin kilidi Mutex / Semafor tasarımından biraz farklıdır. Örneğin, önceki düğümün kilidini serbest bırakıp bir sonrakini yakalayarak çapraz bağlantılı düğümleri doğru şekilde uygulamanın hiçbir yolu yoktur. Ancak mutex ile uygulanması kolaydır:

Node p = getHead();
if (p == null || x == null) return false;
p.lock.acquire();  // Prime loop by acquiring first lock.
// If above acquire fails due to interrupt, the method will
//   throw InterruptedException now, so there is no need for
//   further cleanup.
for (;;) {
Node nextp = null;
boolean found;
try { 
 found = x.equals(p.item); 
 if (!found) { 
   nextp = p.next; 
   if (nextp != null) { 
     try {      // Acquire next lock 
                //   while still holding current 
       nextp.lock.acquire(); 
     } 
     catch (InterruptedException ie) { 
      throw ie;    // Note that finally clause will 
                   //   execute before the throw 
     } 
   } 
 } 
}finally {     // release old lock regardless of outcome 
   p.lock.release();
} 

Şu anda içinde böyle bir sınıf yok java.util.concurrent, ancak Mutext uygulamasını burada Mutex.java'da bulabilirsiniz . Standart kütüphanelere gelince, Semaphore tüm bu işlevselliği ve çok daha fazlasını sağlar.