SonarIssue: Does not release lock on all paths

I have code something like below mentioned. I am releasing the lock in finally block but still sonarqube is showing "Does not release lock on all paths" message.
I tried changing lock.isHeldByCurrentThread() to lock.isLocked() but still no luck. And I am not using lock in any other methods. No clues how to fix this sonar issue.

class Sample{
    ReentrantLock lock = new ReentrantLock();

    public Response<T> method(Inputs input){

        try{
            // some logic
            lock.lock();

        }catch(Exceptions e){
            // handle exception
        }finally{
            if(lock.isHeldByCurrentThread()){
                lock.unlock();
            }
        }
    }
}

What Sonar sees here is that you are acquiring a lock, unconditionally, then releasing it only on some condition. Sonarqube can't tell what the likelihood is that the path where the lock isn't released will ever be chosen, it just sees it could possibly happen.

Also be aware it looks like these methods you're using to check the lock aren't intended for this usage. For instance the documentation for ReentrantLock#isHeldByCurrentThread says:

> this method is typically used for debugging and testing.

which seems like a warning that you should reconsider using it as you're doing here.

It looks like this code is using this method in order to distinguish between the case where an exception is thrown before the lock is acquired, vs the case where the lock has already been acquired, so it can know whether it needs to release the lock.

The answer isn't what method to use to test the lock to see if it is acquired, it is to fix the code so the need for the test doesn't come up. Add another try-block, like this:

class Sample{
    ReentrantLock lock = new ReentrantLock();

    public Response<T> method(Inputs input){

        try{
            // do whatever needs doing prior to acquiring lock
            lock.lock();
            try {
                // do whatever needs doing with lock held
            } finally {
                // release lock on the way out of inner try block
                lock.unlock();
            }
        } catch (Exception e){
            // handle exception thrown from anywhere within outer or inner try block
        }
    }
}

This way if execution progresses to the point that the lock gets acquired, it will get released on the way out. If an exception gets thrown anywhere, it will get caught, and the lock will be unlocked.

TLDR: If you acquire a lock unconditionally, then you should release it unconditionally.