Java에 Mutex가 있습니까?

Java에 Mutex 객체가 있습니까? 아니면 하나를 만드는 방법이 있습니까? 1 허가로 초기화 된 Semaphore 개체가 도움이되지 않기 때문에 묻고 있습니다. 이 경우를 생각해보십시오.

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

첫 번째 획득에서 예외가 발생하면 catch 블록의 해제로 인해 허용이 증가하고 세마포어는 더 이상 이진 세마포어가 아닙니다.

올바른 방법이 될까요?

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

위의 코드는 세마포어가 바이너리인지 확인합니까?

이 페이지를 참조하십시오 : http://www.oracle.com/technetwork/articles/javase/index-140767.html

그것은 당신이 찾고있는 것과 약간 다른 패턴을 가지고 있습니다.

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

이 사용법에서 당신은 release()성공적인acquire()

Java의 모든 객체는 synchronized블록을 사용하여 잠금으로 사용할 수 있습니다 . 또한 예외가 발생하면 자동으로 잠금 해제를 처리합니다.

Object someObject = ...;

synchronized (someObject) {
  ...
}

이에 대한 자세한 내용은 여기에서 읽을 수 있습니다. 고유 잠금 및 동기화

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();

아무도 이것을 명확하게 언급하지 않았지만 이러한 종류의 패턴은 일반적으로 세마포에 적합하지 않습니다. 그 이유는 것입니다 어떤 스레드가 세마포어를 해제 할 수 있습니다,하지만 당신은 보통 원하는 소유자 스레드 원래의 잠금을 해제 할 수 있도록 잠금을 . 이 사용 사례의 경우 Java에서 일반적으로 다음과 같이 생성 할 수있는 ReentrantLocks를 사용합니다.

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

private final Lock lock = new ReentrantLock(true);

일반적인 사용 디자인 패턴은 다음과 같습니다.

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

다음 은이 패턴이 작동하는 것을 볼 수있는 자바 소스 코드의 예입니다.

재진입 잠금에는 공정성을 지원하는 추가 이점이 있습니다.

비 소유권 릴리스 의미 체계가 필요한 경우에만 세마포어를 사용하십시오.

나는 당신이 시도해야한다고 생각합니다 :

세마포어 초기화 동안 :

Semaphore semaphore = new Semaphore(1, true);

그리고 당신의 Runnable Implementation

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

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

원래 게시물의 실수는 try 루프 내부에 설정된 acquire () 호출입니다. 다음은 "이진"세마포어 (Mutex)를 사용하는 올바른 방법입니다.

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

a Semaphore가 바이너리인지 확인하려면 세마포어를 만들 때 허용 개수를 1로 전달해야합니다. Javadoc과는 조금 더 설명을해야합니다.

각 개체의 잠금은 Mutex / Semaphore 디자인과 약간 다릅니다. 예를 들어, 이전 노드의 잠금을 해제하고 다음 노드를 캡처하여 연결된 노드 순회를 올바르게 구현할 방법이 없습니다. 그러나 뮤텍스를 사용하면 쉽게 구현할 수 있습니다.

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();
} 

현재, 거기에 그러한 클래스입니다 java.util.concurrent,하지만 당신은 여기 Mutext 구현을 찾을 수 있습니다 Mutex.java을 . 표준 라이브러리의 경우 Semaphore는이 모든 기능과 그 이상을 제공합니다.