Is there a Mutex in Java?

Is there a Mutex object in java or a way to create one? I am asking because a Semaphore object initialized with 1 permit does not help me. Think of this case:

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

if an exception happens at the first acquire, the release in the catch block will increase the permits, and the semaphore is no longer a binary semaphore.

Will the correct way be?

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

Will the above code ensure that the semaphore will be binary?

8 Answers

Any object in Java can be used as a lock using a synchronized block. This will also automatically take care of releasing the lock when an exception occurs.

Object someObject = ...; synchronized (someObject) { ... } 

You can read more about this here: Intrinsic Locks and Synchronization

See this page:

It has a slightly different pattern which is (I think) what you are looking for:

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

In this usage, you're only calling release() after a successful acquire()

No one has clearly mentioned this, but this kind of pattern is usually not suited for semaphores. The reason is that any thread can release a semaphore, but you usually only want the owner thread that originally locked to be able to unlock. For this use case, in Java, we usually use ReentrantLocks, which can be created like this:

import java.util.concurrent.locks.Lock; import java.util.concurrent.locks.ReentrantLock; private final Lock lock = new ReentrantLock(true); 

And the usual design pattern of usage is:

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

Here is an example in the java source code where you can see this pattern in action.

Reentrant locks have the added benefit of supporting fairness.

Use semaphores only if you need non-ownership-release semantics.

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

I think you should try with :

While Semaphore initialization :

Semaphore semaphore = new Semaphore(1, true); 

And in your Runnable Implementation

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

Mistake in original post is acquire() call set inside the try loop. Here is a correct approach to use "binary" semaphore (Mutex):

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

Each object's lock is little different from Mutex/Semaphore design. For example there is no way to correctly implement traversing linked nodes with releasing previous node's lock and capturing next one. But with mutex it is easy to implement:

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

Currently, there is no such class in java.util.concurrent, but you can find Mutext implementation here Mutex.java. As for standard libraries, Semaphore provides all this functionality and much more.

To ensure that a Semaphore is binary you just need to make sure you pass in the number of permits as 1 when creating the semaphore. The Javadocs have a bit more explanation.