bất cứ ai có thể giải thích cách sử dụng Khóa Reentrant trong java qua Đồng bộ hóa với một số ví dụ tốt nhất

Question

Khi tôi chạy lớp mẫu tại http://javarevisited.blogspot.in/2013/03/reentrantlock-example-in-java-synchronized-difference-vs-lock.html, tôi thấy hành vi tương tự như với synchronized.

Answer 1

Không, bạn thường sẽ không thấy sự khác biệt về hành vi. Nhưng theo trang web, có một vài trường hợp bạn sẽ muốn sử dụng một số ReentrantLock thay vì synchronized.

1. Bạn muốn chủ đề chờ được chọn khá.
2. Bạn muốn sử dụng phương thức tryLock().
3. Bạn muốn làm gián đoạn một chuỗi đang chờ và yêu cầu làm điều gì đó khác.
4. Hiệu suất của ReentrantLock tốt hơn so với đồng bộ hóa và bạn quan tâm đến điều đó.

Nếu bạn không cần bất kỳ cải tiến nào, sử dụng synchronized là tốt và bạn không thể nói sự khác biệt.

Answer 2

Từ the JavaDoc of the ReetrantLock class:

Một reentrant loại trừ lẫn nhau Lock với hành vi cơ bản giống nhau và ngữ nghĩa như khóa màn hình ngầm truy cập dùng synchronized phương pháp và tuyên bố, nhưng với khả năng mở rộng.

Trong ví dụ của bạn, bạn không sử dụng "khả năng mở rộng"; bạn sử dụng phương thức ReentrantLock làm phương án tương đương với phương pháp synchronized (ngoại trừ câu lệnh synchronized, bạn sử dụng this làm khóa). Vì vậy, hai phương pháp phải hành xử giống nhau.

Answer 3

Dưới đây là ba cách, phương pháp, của chuỗi truy cập khóa và một phương pháp để bỏ khóa. Bạn có thể muốn thử triển khai các từ khóa này bằng cách sử dụng từ khóa synchronized. Các khả năng mở rộng và lợi thế của việc sử dụng ReentrantLock sẽ trở nên rõ ràng.

public class DoorLockUsingLock { 

    private int counter= 0; 
    private Thread owner= null; 
    private Lock l = new ReentrantLock(); 
    private Condition notLocked= l.newCondition(); 

    public void lockItDown() throws InterruptedException { 
     l.lockInterruptibly(); 
     try { 
      while ((counter> 0) && (owner!= Thread.currentThread())) { 
       notLocked.await(); 
      } 
      counter++; 
      owner = Thread.currentThread(); 
     } finally { 
      l.unlock(); 
     } 
    } 

    public void lockItDownUninterruptibly() { 
     l.lock(); 
     try { 
      while ((counter > 0) && (owner != Thread.currentThread())) { 
       notLocked.awaitUninterruptibly(); 
      } 
      counter++; 
      owner= Thread.currentThread(); 
     } finally { 
      l.unlock(); 
     } 
    } 

    public boolean tryLockItDown(long timeout, TimeUnit unit) throws InterruptedException { 
     long time = unit.toNanos(timeout); 
     long end = System.nanoTime() + time; 
     boolean success = l.tryLock(timeout, unit); 
     if (!success) { 
      return false; 
     } 
     try { 
      time = end- System.nanoTime(); 
      while ((counter> 0) && (owner != Thread.currentThread()) && (time > 0)) { 
       notLocked.await(time, TimeUnit.NANOSECONDS); 
       time = end - System.nanoTime(); 
      } 
      if (time > 0) { 
       counter++; 
       owner = Thread.currentThread(); 
       return true; 
      } 
      return false; 
     } finally { 
      l.unlock(); 
     } 
    } 

    public void unlockIt() throws IllegalMonitorStateException { 
     l.lock(); 
     try { 
      if (counter== 0) { 
       throw new IllegalMonitorStateException(); 
      } 
      if (owner!= Thread.currentThread()) { 
       throw new IllegalMonitorStateException(); 
      } 
      counter--; 
      if (counter == 0) { 
       owner = null; 
       notLocked.signal(); 
      } 
     } finally { 
      l.unlock(); 
     } 
    } 
}