Question

ReentrantLock允许线程多次对资源进行锁定，

这在执行/效率/功能方面有何好处？

请参阅此链接https://www.geeksforgeeks.org/reentrant-lock-java/

我没有使用内部锁的含义，因为一旦任何一个线程获取了外部锁，外部锁之后就不会有其他线程进入该部分（直到该线程持有时间锁为止），并确保外部锁定之后/之后的部分一次只能由一个线程执行，那么内部锁定在那里的意义是什么，意味着多次进入锁定的意义是什么？

代码：

import java.text.SimpleDateFormat; 
import java.util.Date; 
import java.util.concurrent.ExecutorService; 
import java.util.concurrent.Executors; 
import java.util.concurrent.locks.ReentrantLock; 

class worker implements Runnable 
{ 
  String name; 
  ReentrantLock re; 
  public worker(ReentrantLock rl, String n) 
  { 
    re = rl; 
    name = n; 
  } 
  public void run() 
  { 
    boolean done = false; 
    while (!done) 
    { 
      //Getting Outer Lock 
      boolean ans = re.tryLock(); 

      // Returns True if lock is free 
      if(ans) 
      { 
        try
        { 
          Date d = new Date(); 
          SimpleDateFormat ft = new SimpleDateFormat("hh:mm:ss"); 
          System.out.println("task name - "+ name 
                     + " outer lock acquired at "
                     + ft.format(d) 
                     + " Doing outer work"); 
          Thread.sleep(1500); 

          // Getting Inner Lock 
          re.lock(); 
          try
          { 
            d = new Date(); 
            ft = new SimpleDateFormat("hh:mm:ss"); 
            System.out.println("task name - "+ name 
                       + " inner lock acquired at "
                       + ft.format(d) 
                       + " Doing inner work"); 
            System.out.println("Lock Hold Count - "+ re.getHoldCount()); 
            Thread.sleep(1500); 
          } 
          catch(InterruptedException e) 
          { 
            e.printStackTrace(); 
          } 
          finally
          { 
            //Inner lock release 
            System.out.println("task name - " + name + 
                       " releasing inner lock"); 

            re.unlock(); 
          } 
          System.out.println("Lock Hold Count - " + re.getHoldCount()); 
          System.out.println("task name - " + name + " work done"); 

          done = true; 
        } 
        catch(InterruptedException e) 
        { 
          e.printStackTrace(); 
        } 
        finally
        { 
          //Outer lock release 
          System.out.println("task name - " + name + 
                     " releasing outer lock"); 

          re.unlock(); 
          System.out.println("Lock Hold Count - " + 
                       re.getHoldCount()); 
        } 
      } 
      else
      { 
        System.out.println("task name - " + name + 
                      " waiting for lock"); 
        try
        { 
          Thread.sleep(1000); 
        } 
        catch(InterruptedException e) 
        { 
          e.printStackTrace(); 
        } 
      } 
    } 
  } 
} 

public class test 
{ 
  static final int MAX_T = 2; 
  public static void main(String[] args) 
  { 
    ReentrantLock rel = new ReentrantLock(); 
    ExecutorService pool = Executors.newFixedThreadPool(MAX_T); 
    Runnable w1 = new worker(rel, "Job1"); 
    Runnable w2 = new worker(rel, "Job2"); 
    Runnable w3 = new worker(rel, "Job3"); 
    Runnable w4 = new worker(rel, "Job4"); 
    pool.execute(w1); 
    pool.execute(w2); 
    pool.execute(w3); 
    pool.execute(w4); 
    pool.shutdown(); 
  } 
}

Answer 1

我认为解释它的工作原理是多余的，我们应该只使用lock（）或tryLock（）方法之一：

如果线程有多个任务要执行，其中一些任务与锁无关，那么您应该使用tryLock（）。如果线程需要执行的所有任务都依赖于锁，则应使用lock（）。

也就是说，当线程具有或可以获取独立于锁获取的其他工作时，应该在lock（）上使用tryLock（）。

-----可选：

假设您有四个任务（1到3），这些任务由具有两个工作线程A和B的线程池执行。任务1和2共享一个资源，每次必须由一个线程访问该资源以防止腐败。

现在，如果您只是不经试用就锁定，则可能会遇到以下情况：

线程A启动任务1；
线程A获取资源锁；
线程B启动任务2；
线程B尝试获取锁，但被锁定（休眠）；
线程A完成任务1，释放锁；
线程B唤醒，但是线程A尚未切换；
线程A启动任务3；
线程B尝试再次获取锁；
线程B获取锁并完成任务2；
线程A完成任务3。

请注意，lock（）将线程挂起，直到释放锁为止，因此直到线程A释放锁为止，线程B完全没有用。线程B本可以启动任务3而不是等待锁定，然后同时完成它。

使用try-lock的算法可以这样执行：

线程A启动任务1；
线程A测试并获取锁；
线程B启动任务2；
线程B测试锁，跳过任务2；
线程B启动任务3；
线程A完成任务1，释放锁；
线程A启动任务2；
线程B完成任务3；
没有更多任务，线程B进入睡眠状态； </ li>
线程A完成任务2，释放锁。

请注意，tryLock（）不会挂起调用线程，因此可以跳过阻止任务，而线程B而是执行非阻止任务。如果任务1和2较长，并且还有其他几个简短的非阻塞任务，则它们都可以在任务1完成或任务2开始之前完成。

当然，实现线程池和任务管理比单纯的锁定要复杂一些：可能必须暂停任务并将其返回给池；释放任何锁时，应该唤醒处于睡眠状态的空闲线程。

如果您有许多非阻塞任务（或至少不是在同一单个锁上阻塞）以及一些阻塞任务，那是值得的麻烦，但是如果所有任务都在同一资源上阻塞，那甚至不值得首先实现多线程。

Answer 2

假设在一个类中您有两个方法m1和m2，两者都已同步并且m2正在调用m1。在这种情况下，如果线程a已锁定m1并且不允许再次锁定，则该线程将继续等待调用m2（因为它已经具有锁定）

更多详细信息：

https://stackoverflow.com/questions/18596080/java-concurrent-reentrantlock-why-we-want-to-acquire-the-same-lock-multiple-ti

ReentrantLock允许线程多次对资源进行锁定

2 个答案: