Có Mutex trong Java không?

Có đối tượng Mutex trong java hay cách tạo một đối tượng? Tôi đang hỏi vì một đối tượng Semaphore được khởi tạo với 1 giấy phép không giúp được tôi. Hãy nghĩ đến trường hợp này:

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

nếu một ngoại lệ xảy ra ở lần mua đầu tiên, việc phát hành trong khối catch sẽ tăng giấy phép và semaphore không còn là semaphore nhị phân nữa.

Cách chính xác sẽ là?

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

Đoạn mã trên có đảm bảo rằng semaphore sẽ là nhị phân không?

Xem trang này: http://www.oracle.com/technetwork/articles/javase/index-140767.html

Nó có một mô hình hơi khác, đó là (tôi nghĩ) những gì bạn đang tìm kiếm:

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

Trong cách sử dụng này, bạn chỉ gọi release()sau khi thành côngacquire()

Bất kỳ đối tượng nào trong Java đều có thể được sử dụng làm khóa bằng cách sử dụng một synchronizedkhối. Thao tác này cũng sẽ tự động giải phóng khóa khi có ngoại lệ.

Object someObject = ...;

synchronized (someObject) {
  ...
}

Bạn có thể đọc thêm về điều này tại đây: Khóa nội tại và đồng bộ hóa

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

Không ai đã đề cập rõ ràng về điều này, nhưng loại mô hình này thường không phù hợp với các vòng bán kết. Nguyên nhân là do bất kỳ chủ đề có thể phát hành một semaphore, nhưng bạn thường chỉ muốn thread chủ sở hữu mà ban đầu được khóa để có thể mở khóa . Đối với trường hợp sử dụng này, trong Java, chúng tôi thường sử dụng ReentrantLocks, có thể được tạo như sau:

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

private final Lock lock = new ReentrantLock(true);

Và kiểu thiết kế thông thường được sử dụng là:

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

Đây là một ví dụ trong mã nguồn java nơi bạn có thể thấy mẫu này hoạt động.

Khóa Reentrant có thêm lợi ích là hỗ trợ sự công bằng.

Chỉ sử dụng semaphores nếu bạn cần ngữ nghĩa không thuộc quyền sở hữu-phát hành.

Tôi nghĩ bạn nên thử với:

Trong khi khởi tạo Semaphore:

Semaphore semaphore = new Semaphore(1, true);

Và trong của bạn Runnable Implementation

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

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

Sai lầm trong bài viết gốc là cuộc gọi get () được đặt bên trong vòng lặp thử. Đây là một cách tiếp cận đúng để sử dụng semaphore "nhị phân" (Mutex):

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

Để đảm bảo rằng a Semaphorelà nhị phân, bạn chỉ cần đảm bảo rằng bạn chuyển số lượng giấy phép là 1 khi tạo semaphore. Các Javadocs có lời giải thích thêm một chút.

Khóa của mỗi đối tượng hơi khác so với thiết kế Mutex / Semaphore. Ví dụ: không có cách nào để triển khai chính xác việc duyệt qua các nút được liên kết với việc giải phóng khóa của nút trước và nắm bắt nút tiếp theo. Nhưng với mutex, nó rất dễ thực hiện:

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

Hiện tại, không có lớp nào như vậy trong java.util.concurrent, nhưng bạn có thể tìm thấy triển khai Mutext tại đây Mutex.java . Đối với các thư viện tiêu chuẩn, Semaphore cung cấp tất cả các chức năng này và nhiều hơn nữa.