Чи є Mutex на Java?

Чи є об'єкт Mutex в Java або спосіб створити його? Я прошу, тому що об'єкт Semaphore, ініціалізований з 1 дозволом, не допомагає мені. Подумайте про цей випадок:

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

якщо виняток трапляється при першому придбанні, вивільнення в блоці вилову збільшить дозволи, і семафор більше не буде бінарним семафором.

Чи буде правильний шлях?

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

Ось приклад у вихідному коді Java, де ви можете бачити цю схему в дії.

Замки ретранса мають додаткову перевагу підтримки справедливості.

Використовуйте семафори лише в тому випадку, якщо вам потрібна семантика, яка не належить до власності.

Я думаю, вам слід спробувати:

Під час ініціалізації Semaphore:

Semaphore semaphore = new Semaphore(1, true);

І у вашому Runnable Implementation

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

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

Помилка в оригінальній публікації - це набір виклику набору (), який знаходиться у циклі спробу. Ось правильний підхід до використання "бінарного" семафору (Mutex):

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

Щоб переконатися, що a Semaphoreє двійковим, вам просто потрібно переконатися, що ви перетворюєте кількість дозволів як 1 під час створення семафору. У Javadocs є трохи більше пояснень.

Кожен замок об'єкта мало відрізняється від дизайну Mutex / Semaphore. Наприклад, немає способу правильно здійснити проходження пов'язаних вузлів, звільнивши блокування попереднього вузла та захопивши наступний. Але з mutex це легко реалізувати:

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 забезпечує всю цю функціональність та багато іншого.