มี 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) {
  ...
}

คุณสามารถอ่านเพิ่มเติมเกี่ยวกับสิ่งนี้ได้ที่นี่: Intrinsic Locks and Synchronization

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 ที่คุณสามารถเห็นรูปแบบนี้ในการทำงาน

การล็อกกลับมีประโยชน์เพิ่มเติมในการสนับสนุนความเป็นธรรม

ใช้ semaphores เฉพาะในกรณีที่คุณต้องการความหมายแบบไม่เป็นเจ้าของ

ฉันคิดว่าคุณควรลองใช้:

ในขณะที่การเริ่มต้น 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 มีฟังก์ชันทั้งหมดนี้และอื่น ๆ อีกมากมาย