Есть ли мьютекс в Java?

Есть ли объект Mutex в Java или способ его создать? Я спрашиваю, потому что объект Semaphore, инициализированный с 1 разрешением, мне не помогает. Подумайте об этом случае:

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

Вот пример исходного кода Java, где вы можете увидеть этот шаблон в действии.

У повторных блокировок есть дополнительное преимущество в виде поддержки справедливости.

Используйте семафоры только в том случае, если вам нужна семантика без права собственности.

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

При инициализации семафора:

Semaphore semaphore = new Semaphore(1, true);

И в твоем Runnable Implementation

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

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

Ошибка в исходном посте - это вызов функции Accele (), установленный внутри цикла try. Вот правильный подход к использованию «двоичного» семафора (Mutex):

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

Чтобы гарантировать, что a Semaphoreявляется двоичным, вам просто нужно убедиться, что вы передаете количество разрешений как 1 при создании семафора. В Javadocs есть немного больше объяснений.

Блокировка каждого объекта мало отличается от дизайна мьютексов / семафоров. Например, нет способа правильно реализовать обход связанных узлов с снятием блокировки предыдущего узла и захватом следующего. Но с мьютексом легко реализовать:

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 предоставляет все эти функции и многое другое.