Apakah ada Mutex di Jawa?

Apakah ada objek Mutex di java atau cara membuatnya? Saya bertanya karena objek Semaphore yang diinisialisasi dengan 1 izin tidak membantu saya. Pikirkan kasus ini:

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

jika pengecualian terjadi pada perolehan pertama, rilis di blok catch akan meningkatkan izin, dan semaphore tidak lagi menjadi semaphore biner.

Akankah cara yang benar?

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

Akankah kode di atas memastikan bahwa semaphore akan menjadi biner?

Lihat halaman ini: http://www.oracle.com/technetwork/articles/javase/index-140767.html

Ini memiliki pola yang sedikit berbeda yang (menurut saya) apa yang Anda cari:

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

Dalam penggunaan ini, Anda hanya menelepon release()setelah berhasilacquire()

Objek apa pun di Java dapat digunakan sebagai kunci menggunakan synchronizedblok. Ini juga akan secara otomatis menangani pelepasan kunci ketika pengecualian terjadi.

Object someObject = ...;

synchronized (someObject) {
  ...
}

Anda dapat membaca lebih lanjut tentang ini di sini: Kunci Intrinsik dan Sinkronisasi

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

Tidak ada yang secara jelas menyebutkan ini, tetapi pola semacam ini biasanya tidak cocok untuk semaphore. Alasannya adalah bahwa utas apa pun dapat melepaskan semaphore, tetapi Anda biasanya hanya ingin utas pemilik yang awalnya terkunci dapat membuka kunci . Untuk kasus penggunaan ini, di Java, kami biasanya menggunakan ReentrantLocks, yang dapat dibuat seperti ini:

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

private final Lock lock = new ReentrantLock(true);

Dan pola desain penggunaan yang biasa adalah:

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

Berikut adalah contoh dalam kode sumber java di mana Anda dapat melihat pola ini beraksi.

Kunci reentrant memiliki manfaat tambahan untuk mendukung keadilan.

Gunakan semaphore hanya jika Anda membutuhkan semantik non-kepemilikan-rilis.

Saya pikir Anda harus mencoba dengan:

Sedangkan inisialisasi Semaphore:

Semaphore semaphore = new Semaphore(1, true);

Dan di Runnable Implementation

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

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

Kesalahan dalam posting asli adalah panggilan gain () yang diatur di dalam loop percobaan. Berikut adalah pendekatan yang benar untuk menggunakan semaphore "biner" (Mutex):

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

Untuk memastikan bahwa a Semaphoreadalah biner, Anda hanya perlu memastikan bahwa Anda memasukkan jumlah izin sebagai 1 saat membuat semaphore. The Javadocs memiliki sedikit lebih penjelasan.

Setiap kunci objek sedikit berbeda dari desain Mutex / Semaphore. Misalnya, tidak ada cara untuk mengimplementasikan melintasi node tertaut dengan benar dengan melepaskan kunci node sebelumnya dan menangkap yang berikutnya. Tetapi dengan mutex mudah diimplementasikan:

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

Saat ini, tidak ada kelas seperti itu di java.util.concurrent, tetapi Anda dapat menemukan implementasi Mutext di sini Mutex.java . Adapun pustaka standar, Semaphore menyediakan semua fungsi ini dan banyak lagi.