diff --git a/CHANGELOG.md b/CHANGELOG.md
index 08407e06ecb..6fd4d804cf8 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -5,6 +5,9 @@ This is the changelog for SpotBugs. This follows [Keep a Changelog v1.0.0](http:
 Currently the versioning policy of this project follows [Semantic Versioning v2.0.0](http://semver.org/spec/v2.0.0.html).
 
 ## Unreleased - 2023-??-??
+### Added
+* New bug type `CWO_CLOSED_WITHOUT_OPENED` for locks that might be released without even being acquired. (See [SEI CERT rule LCK08-J](https://wiki.sei.cmu.edu/confluence/display/java/LCK08-J.+Ensure+actively+held+locks+are+released+on+exceptional+conditions))([#2055](https://github.com/spotbugs/spotbugs/pull/2055))
+
 ### Changed
 - Bump up Apache Commons BCEL to the version 6.6.1 ([#2223](https://github.com/spotbugs/spotbugs/pull/2223))
 - Bump up slf4j-api to 2.0.3 ([#2220](https://github.com/spotbugs/spotbugs/pull/2220))
diff --git a/spotbugs-tests/src/test/java/edu/umd/cs/findbugs/detect/FindUnreleasedLockTest.java b/spotbugs-tests/src/test/java/edu/umd/cs/findbugs/detect/FindUnreleasedLockTest.java
new file mode 100644
index 00000000000..f2d4ecad79f
--- /dev/null
+++ b/spotbugs-tests/src/test/java/edu/umd/cs/findbugs/detect/FindUnreleasedLockTest.java
@@ -0,0 +1,59 @@
+package edu.umd.cs.findbugs.detect;
+
+import edu.umd.cs.findbugs.AbstractIntegrationTest;
+import edu.umd.cs.findbugs.test.matcher.BugInstanceMatcher;
+import edu.umd.cs.findbugs.test.matcher.BugInstanceMatcherBuilder;
+import org.junit.Test;
+
+import static edu.umd.cs.findbugs.test.CountMatcher.containsExactly;
+import static org.hamcrest.CoreMatchers.hasItem;
+import static org.hamcrest.MatcherAssert.assertThat;
+
+public class FindUnreleasedLockTest extends AbstractIntegrationTest {
+
+    @Test
+    public void doesNotFindSSDBug_ifLockIsClosedInAProperWay() {
+        performAnalysis("unreleasedLock/ProperlyClosedLock.class");
+
+        assertAnalyzedClassHasNoBugs();
+    }
+
+    @Test
+    public void findPossibleUnlockCall_withoutLockCall() {
+        performAnalysis("unreleasedLock/ThrowExceptionAndUnlockBeforeLock.class");
+
+        assertAnalyzedClassHasBug("CWO_CLOSED_WITHOUT_OPENED", 1);
+        assertExactPlaceOfBug("ThrowExceptionAndUnlockBeforeLock", "doSomething", "CWO_CLOSED_WITHOUT_OPENED");
+    }
+
+    @Test
+    public void findUnresolvedLock_onExceptionalCondition() {
+        performAnalysis("unreleasedLock/UnreleasedLock.class");
+
+        assertAnalyzedClassHasBug("UL_UNRELEASED_LOCK_EXCEPTION_PATH", 1);
+        assertExactPlaceOfBug("UnreleasedLock", "doSomething", "UL_UNRELEASED_LOCK_EXCEPTION_PATH");
+    }
+
+    private void assertAnalyzedClassHasNoBugs() {
+        final BugInstanceMatcher bugTypeMatcher = new BugInstanceMatcherBuilder()
+                .build();
+        assertThat(getBugCollection(), containsExactly(0, bugTypeMatcher));
+    }
+
+    private void assertAnalyzedClassHasBug(String bugType, int numberOfBugs) {
+        final BugInstanceMatcher bugTypeMatcher = new BugInstanceMatcherBuilder()
+                .bugType(bugType)
+                .build();
+        assertThat(getBugCollection(), containsExactly(numberOfBugs, bugTypeMatcher));
+    }
+
+    private void assertExactPlaceOfBug(String className, String methodName, String bugType) {
+        final BugInstanceMatcher bugInstanceMatcher = new BugInstanceMatcherBuilder()
+                .bugType(bugType)
+                .inClass(className)
+                .inMethod(methodName)
+                .build();
+        assertThat(getBugCollection(), hasItem(bugInstanceMatcher));
+    }
+
+}
diff --git a/spotbugs/etc/findbugs.xml b/spotbugs/etc/findbugs.xml
index e9be54de7d9..7252d94e28e 100644
--- a/spotbugs/etc/findbugs.xml
+++ b/spotbugs/etc/findbugs.xml
@@ -497,7 +497,8 @@
           <Detector class="edu.umd.cs.findbugs.detect.FindUselessControlFlow" speed="fast"
                     reports="UCF_USELESS_CONTROL_FLOW,UCF_USELESS_CONTROL_FLOW_NEXT_LINE"/>
           <Detector class="edu.umd.cs.findbugs.detect.FindUnreleasedLock" speed="moderate"
-                    requirejre="1.5" reports="UL_UNRELEASED_LOCK,UL_UNRELEASED_LOCK_EXCEPTION_PATH"/>
+                    requirejre="1.5"
+                    reports="UL_UNRELEASED_LOCK,UL_UNRELEASED_LOCK_EXCEPTION_PATH,CWO_CLOSED_WITHOUT_OPENED"/>
           <Detector class="edu.umd.cs.findbugs.detect.FindRefComparison" speed="slow"
                     reports="ES_COMPARING_STRINGS_WITH_EQ,ES_COMPARING_PARAMETER_STRING_WITH_EQ,RC_REF_COMPARISON,RC_REF_COMPARISON_BAD_PRACTICE,RC_REF_COMPARISON_BAD_PRACTICE_BOOLEAN,EC_UNRELATED_TYPES,EC_NULL_ARG,EC_UNRELATED_CLASS_AND_INTERFACE,EC_UNRELATED_INTERFACES,EC_ARRAY_AND_NONARRAY,EC_INCOMPATIBLE_ARRAY_COMPARE,EC_BAD_ARRAY_COMPARE,EC_UNRELATED_TYPES_USING_POINTER_EQUALITY,DMI_DOH"/>
           <Detector class="edu.umd.cs.findbugs.detect.FindMismatchedWaitOrNotify" speed="moderate"
@@ -1286,4 +1287,5 @@
           <BugPattern abbrev="PERM" type="PERM_SUPER_NOT_CALLED_IN_GETPERMISSIONS" category="MALICIOUS_CODE" />
           <BugPattern abbrev="USC" type="USC_POTENTIAL_SECURITY_CHECK_BASED_ON_UNTRUSTED_SOURCE"
                     category="MALICIOUS_CODE"/>
+          <BugPattern abbrev="CWO" type="CWO_CLOSED_WITHOUT_OPENED" category="MT_CORRECTNESS" />
 </FindbugsPlugin>
diff --git a/spotbugs/etc/messages.xml b/spotbugs/etc/messages.xml
index 77c964f2ab9..27acc6c14ab 100644
--- a/spotbugs/etc/messages.xml
+++ b/spotbugs/etc/messages.xml
@@ -1054,13 +1054,14 @@ Returning a zero length array is generally preferred in this context to returnin
   </Detector>
   <Detector class="edu.umd.cs.findbugs.detect.FindUnreleasedLock">
     <Details>
-<![CDATA[
-<p> This detector looks for JSR-166 (<code>java.util.concurrent</code>)
-locks which are acquired, but not released on all paths out of the method.&nbsp;
-It is a moderately fast detector.&nbsp; Note that in order to use this
-detector, you need to have the <code>java.util.concurrent</code> package
-in the auxiliary classpath (or be analyzing the package itself).</p>
-]]>
+      <![CDATA[
+        <p> This detector looks for JSR-166 (<code>java.util.concurrent</code>)
+        locks which are acquired, but not released on all paths out of the method.&nbsp;
+        The detector also detects if a lock is released without even being opened in the first place.
+        It is a moderately fast detector.&nbsp; Note that in order to use this
+        detector, you need to have the <code>java.util.concurrent</code> package
+        in the auxiliary classpath (or be analyzing the package itself).</p>
+      ]]>
     </Details>
   </Detector>
   <Detector class="edu.umd.cs.findbugs.detect.FindRefComparison">
@@ -8785,6 +8786,18 @@ Using floating-point variables should not be used as loop counters, as they are
       </p>]]>
     </Details>
   </BugPattern>
+  <BugPattern type="CWO_CLOSED_WITHOUT_OPENED">
+    <ShortDescription>Method releases lock without opening it</ShortDescription>
+    <LongDescription>{1} releases lock without acquiring it in the first place</LongDescription>
+    <Details>
+      <![CDATA[
+        <p> This method releases a JSR-166 (<code>java.util.concurrent</code>) lock,
+        but it is possible that the lock is not even acquired at this point,
+        due to an exception thrower method before the locking.
+        </p>
+      ]]>
+    </Details>
+  </BugPattern>
   <!--
   **********************************************************************
    BugCodes
@@ -8938,4 +8951,5 @@ Using floating-point variables should not be used as loop counters, as they are
   <BugCode abbrev="THROWS">Exception throwing related problems</BugCode>
   <BugCode abbrev="PERM">Custom class loader does not call its superclass's getPermissions()</BugCode>
   <BugCode abbrev="USC">Potential security check based on untrusted source</BugCode>
+  <BugCode abbrev="CWO">Lock closed without being opened in the first place</BugCode>
 </MessageCollection>
diff --git a/spotbugs/src/main/java/edu/umd/cs/findbugs/ba/ResourceValueAnalysis.java b/spotbugs/src/main/java/edu/umd/cs/findbugs/ba/ResourceValueAnalysis.java
index 8fb4b4c957e..a62d9664225 100644
--- a/spotbugs/src/main/java/edu/umd/cs/findbugs/ba/ResourceValueAnalysis.java
+++ b/spotbugs/src/main/java/edu/umd/cs/findbugs/ba/ResourceValueAnalysis.java
@@ -106,6 +106,9 @@ public void meetInto(ResourceValueFrame fact, Edge edge, ResourceValueFrame resu
                 // If status is OPEN, downgrade to OPEN_ON_EXCEPTION_PATH
                 tmpFact = modifyFrame(fact, null);
                 tmpFact.setStatus(ResourceValueFrame.OPEN_ON_EXCEPTION_PATH);
+            } else {
+                tmpFact = modifyFrame(fact, null);
+                tmpFact.setStatus(ResourceValueFrame.NOT_OPEN_ON_EXCEPTION_PATH);
             }
 
             if (fact.isValid()) {
@@ -137,6 +140,11 @@ public void meetInto(ResourceValueFrame fact, Edge edge, ResourceValueFrame resu
                     tmpFact.pushValue(ResourceValue.notInstance());
                 }
             }
+        } else {
+            if (result.getStatus() == ResourceValueFrame.NOT_OPEN_ON_EXCEPTION_PATH && fact.getStatus() == ResourceValueFrame.CLOSED) {
+                tmpFact = modifyFrame(fact, null);
+                tmpFact.setStatus(ResourceValueFrame.CLOSED_WITHOUT_OPENED);
+            }
         }
 
         // Make the resource nonexistent if it is compared against null
diff --git a/spotbugs/src/main/java/edu/umd/cs/findbugs/ba/ResourceValueFrame.java b/spotbugs/src/main/java/edu/umd/cs/findbugs/ba/ResourceValueFrame.java
index fe8faf315ce..b8040f896e9 100644
--- a/spotbugs/src/main/java/edu/umd/cs/findbugs/ba/ResourceValueFrame.java
+++ b/spotbugs/src/main/java/edu/umd/cs/findbugs/ba/ResourceValueFrame.java
@@ -37,20 +37,31 @@ public class ResourceValueFrame extends Frame<ResourceValue> {
      */
     public static final int OPEN_ON_EXCEPTION_PATH = 2;
 
+    /**
+     * The resource is closed without being opened in the first place.
+     */
+    public static final int CLOSED_WITHOUT_OPENED = 3;
+
     /**
      * The resource is closed (or unlocked, etc).
      */
-    public static final int CLOSED = 3;
+    public static final int CLOSED = 4;
 
     /**
      * The resource has been created, but is not open.
      */
-    public static final int CREATED = 4;
+    public static final int CREATED = 5;
 
     /**
      * The resource doesn't exist.
      */
-    public static final int NONEXISTENT = 5;
+    public static final int NONEXISTENT = 6;
+
+    /**
+     * The resource is NOT open (or locked, etc) on paths that include exception
+     * control flow.
+     */
+    public static final int NOT_OPEN_ON_EXCEPTION_PATH = 7;
 
     private int status;
 
@@ -84,8 +95,8 @@ public void copyFrom(Frame<ResourceValue> other_) {
         this.status = other.status;
     }
 
-    private static final String[] statusList = { "(escaped)", "(open)", "(open_exception)", "(closed)", "(created)",
-        "(nonexistent)" };
+    private static final String[] statusList = { "(escaped)", "(open)", "(open_exception)", "(closed_without_opened)", "(closed)", "(created)",
+        "(nonexistent)", "(not_open_exception)" };
 
     @Override
     public String toString() {
diff --git a/spotbugs/src/main/java/edu/umd/cs/findbugs/detect/FindUnreleasedLock.java b/spotbugs/src/main/java/edu/umd/cs/findbugs/detect/FindUnreleasedLock.java
index 3a1dac5c7c8..852707dd699 100644
--- a/spotbugs/src/main/java/edu/umd/cs/findbugs/detect/FindUnreleasedLock.java
+++ b/spotbugs/src/main/java/edu/umd/cs/findbugs/detect/FindUnreleasedLock.java
@@ -21,6 +21,7 @@
 
 import java.util.BitSet;
 
+import java.util.Optional;
 import org.apache.bcel.Const;
 import org.apache.bcel.classfile.Constant;
 import org.apache.bcel.classfile.ConstantClass;
@@ -108,29 +109,40 @@ public void transferInstruction(InstructionHandle handle, BasicBlock basicBlock)
             final ConstantPoolGen cpg = getCPG();
             final ResourceValueFrame frame = getFrame();
 
-            int status = -1;
+            int status = ResourceValueFrame.NONEXISTENT;
 
             if (DEBUG) {
+                System.out.println("Before transferInstruction status of frame: " + frame.getStatus());
                 System.out.println("PC : " + handle.getPosition() + " " + ins);
-            }
-            if (DEBUG && ins instanceof InvokeInstruction) {
-                System.out.println("  " + ins.toString(cpg.getConstantPool()));
-            }
-            if (DEBUG) {
-                System.out.println("resource frame before instruction: " + frame.toString());
+                if (ins instanceof InvokeInstruction) {
+                    System.out.println("  " + ins.toString(cpg.getConstantPool()));
+                }
+                System.out.println("resource frame before instruction: " + frame);
             }
 
             // Is a lock acquired or released by this instruction?
             Location creationPoint = lock.getLocation();
-            if (handle == creationPoint.getHandle() && basicBlock == creationPoint.getBasicBlock()) {
+            if (frame.getStatus() == ResourceValueFrame.CLOSED_WITHOUT_OPENED) {
+                status = ResourceValueFrame.CLOSED_WITHOUT_OPENED;
+                if (DEBUG) {
+                    System.out.println("CLOSED WITHOUT OPENED");
+                }
+            } else if (handle == creationPoint.getHandle() && basicBlock == creationPoint.getBasicBlock()) {
                 status = ResourceValueFrame.OPEN;
                 if (DEBUG) {
                     System.out.println("OPEN");
                 }
             } else if (resourceTracker.isResourceClose(basicBlock, handle, cpg, lock, frame)) {
-                status = ResourceValueFrame.CLOSED;
-                if (DEBUG) {
-                    System.out.println("CLOSE");
+                if (frame.getStatus() == ResourceValueFrame.NOT_OPEN_ON_EXCEPTION_PATH) {
+                    status = ResourceValueFrame.CLOSED_WITHOUT_OPENED;
+                    if (DEBUG) {
+                        System.out.println("CLOSED WITHOUT OPENED");
+                    }
+                } else {
+                    status = ResourceValueFrame.CLOSED;
+                    if (DEBUG) {
+                        System.out.println("CLOSE");
+                    }
                 }
             }
 
@@ -166,11 +178,11 @@ public void transferInstruction(InstructionHandle handle, BasicBlock basicBlock)
             }
 
             // If needed, update frame status
-            if (status != -1) {
+            if (status != ResourceValueFrame.NONEXISTENT) {
                 frame.setStatus(status);
             }
             if (DEBUG) {
-                System.out.println("resource frame after instruction: " + frame.toString());
+                System.out.println("resource frame after instruction: " + frame);
             }
 
         }
@@ -185,9 +197,7 @@ class LockResourceTracker implements ResourceTracker<Lock> {
         private final RepositoryLookupFailureCallback lookupFailureCallback;
 
         private final CFG cfg;
-
         private final ValueNumberDataflow vnaDataflow;
-
         private final IsNullValueDataflow isNullDataflow;
 
         public LockResourceTracker(RepositoryLookupFailureCallback lookupFailureCallback, CFG cfg,
@@ -202,11 +212,12 @@ public LockResourceTracker(RepositoryLookupFailureCallback lookupFailureCallback
         public Lock isResourceCreation(BasicBlock basicBlock, InstructionHandle handle, ConstantPoolGen cpg)
                 throws DataflowAnalysisException {
 
-            InvokeInstruction inv = toInvokeInstruction(handle.getInstruction());
-            if (inv == null) {
+            Optional<InvokeInstruction> maybeInv = toInvokeInstruction(handle.getInstruction());
+            if (!maybeInv.isPresent()) {
                 return null;
             }
 
+            InvokeInstruction inv = maybeInv.get();
             String className = inv.getClassName(cpg);
             String methodName = inv.getName(cpg);
             String methodSig = inv.getSignature(cpg);
@@ -220,8 +231,6 @@ public Lock isResourceCreation(BasicBlock basicBlock, InstructionHandle handle,
                     ValueNumber lockValue = frame.getTopValue();
                     if (DEBUG) {
                         System.out.println("Lock value is " + lockValue.getNumber() + ", frame=" + frame.toString());
-                    }
-                    if (DEBUG) {
                         ++numAcquires;
                     }
                     return new Lock(location, className, lockValue);
@@ -233,13 +242,13 @@ public Lock isResourceCreation(BasicBlock basicBlock, InstructionHandle handle,
         }
 
         @Override
-        public boolean mightCloseResource(BasicBlock basicBlock, InstructionHandle handle, ConstantPoolGen cpg)
-                throws DataflowAnalysisException {
-            InvokeInstruction inv = toInvokeInstruction(handle.getInstruction());
-            if (inv == null) {
+        public boolean mightCloseResource(BasicBlock basicBlock, InstructionHandle handle, ConstantPoolGen cpg) {
+            Optional<InvokeInstruction> maybeInv = toInvokeInstruction(handle.getInstruction());
+            if (!maybeInv.isPresent()) {
                 return false;
             }
 
+            InvokeInstruction inv = maybeInv.get();
             String className = inv.getClassName(cpg);
             String methodName = inv.getName(cpg);
             String methodSig = inv.getSignature(cpg);
@@ -247,7 +256,6 @@ public boolean mightCloseResource(BasicBlock basicBlock, InstructionHandle handl
             try {
                 if ("unlock".equals(methodName) && "()V".equals(methodSig)
                         && Hierarchy.isSubtype(className, "java.util.concurrent.locks.Lock")) {
-
                     return true;
                 }
             } catch (ClassNotFoundException e) {
@@ -315,7 +323,6 @@ public boolean ignoreExceptionEdge(Edge edge, Lock resource, ConstantPoolGen cpg
                 } else if (ins instanceof InvokeInstruction) {
                     InvokeInstruction iins = (InvokeInstruction) ins;
                     String methodName = iins.getMethodName(cpg);
-                    // System.out.println("Method " + methodName);
                     if (methodName.startsWith("access$")) {
                         return true;
                     }
@@ -343,12 +350,12 @@ public boolean isParamInstance(Lock resource, int slot) {
             return false;
         }
 
-        private InvokeInstruction toInvokeInstruction(Instruction ins) {
+        private Optional<InvokeInstruction> toInvokeInstruction(Instruction ins) {
             short opcode = ins.getOpcode();
             if (opcode != Const.INVOKEVIRTUAL && opcode != Const.INVOKEINTERFACE) {
-                return null;
+                return Optional.empty();
             }
-            return (InvokeInstruction) ins;
+            return Optional.of((InvokeInstruction) ins);
         }
     }
 
@@ -383,8 +390,8 @@ public void visitClassContext(ClassContext classContext) {
         boolean sawUtilConcurrentLocks = false;
         for (Constant c : jclass.getConstantPool().getConstantPool()) {
             if (c instanceof ConstantMethodref) {
-                ConstantMethodref m = (ConstantMethodref) c;
-                ConstantClass cl = (ConstantClass) jclass.getConstantPool().getConstant(m.getClassIndex());
+                ConstantMethodref constantMethodref = (ConstantMethodref) c;
+                ConstantClass cl = (ConstantClass) jclass.getConstantPool().getConstant(constantMethodref.getClassIndex());
                 ConstantUtf8 name = (ConstantUtf8) jclass.getConstantPool().getConstant(cl.getNameIndex());
                 String nameAsString = name.getBytes();
                 if (nameAsString.startsWith("java/util/concurrent/locks")) {
@@ -410,7 +417,7 @@ public boolean prescreen(ClassContext classContext, Method method, boolean might
 
         MethodGen methodGen = classContext.getMethodGen(method);
 
-        return methodGen != null && methodGen.getName().toLowerCase().indexOf("lock") == -1
+        return methodGen != null && !methodGen.getName().toLowerCase().contains("lock")
                 && (bytecodeSet.get(Const.INVOKEVIRTUAL) || bytecodeSet.get(Const.INVOKEINTERFACE));
     }
 
@@ -433,23 +440,30 @@ public void inspectResult(ClassContext classContext, MethodGen methodGen, CFG cf
         }
         int exitStatus = exitFrame.getStatus();
 
-        if (exitStatus == ResourceValueFrame.OPEN || exitStatus == ResourceValueFrame.OPEN_ON_EXCEPTION_PATH) {
+        if (exitStatus == ResourceValueFrame.OPEN
+                || exitStatus == ResourceValueFrame.OPEN_ON_EXCEPTION_PATH
+                || exitStatus == ResourceValueFrame.CLOSED_WITHOUT_OPENED) {
+            String sourceFile = javaClass.getSourceFileName();
+            Location location = resource.getLocation();
+            InstructionHandle handle = location.getHandle();
+            InstructionHandle nextInstruction = handle.getNext();
+
+            // Exit early and don't report as error, intentionally
+            if (nextInstruction.getInstruction() instanceof RETURN) {
+                return;
+            }
+
             String bugType;
             int priority;
             if (exitStatus == ResourceValueFrame.OPEN) {
                 bugType = "UL_UNRELEASED_LOCK";
                 priority = HIGH_PRIORITY;
-            } else {
+            } else if (exitStatus == ResourceValueFrame.OPEN_ON_EXCEPTION_PATH) {
                 bugType = "UL_UNRELEASED_LOCK_EXCEPTION_PATH";
                 priority = NORMAL_PRIORITY;
-            }
-
-            String sourceFile = javaClass.getSourceFileName();
-            Location location = resource.getLocation();
-            InstructionHandle handle = location.getHandle();
-            InstructionHandle nextInstruction = handle.getNext();
-            if (nextInstruction.getInstruction() instanceof RETURN) {
-                return; // don't report as error; intentional
+            } else {
+                bugType = "CWO_CLOSED_WITHOUT_OPENED";
+                priority = LOW_PRIORITY;
             }
             bugAccumulator.accumulateBug(new BugInstance(this, bugType, priority).addClassAndMethod(methodGen, sourceFile),
                     SourceLineAnnotation.fromVisitedInstruction(classContext, methodGen, sourceFile, handle));
diff --git a/spotbugsTestCases/src/java/unreleasedLock/ProperlyClosedLock.java b/spotbugsTestCases/src/java/unreleasedLock/ProperlyClosedLock.java
new file mode 100644
index 00000000000..3c2c5b65222
--- /dev/null
+++ b/spotbugsTestCases/src/java/unreleasedLock/ProperlyClosedLock.java
@@ -0,0 +1,33 @@
+package unreleasedLock;
+
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.FileNotFoundException;
+import java.io.IOException;
+import java.io.InputStream;
+import java.util.concurrent.locks.Lock;
+import java.util.concurrent.locks.ReentrantLock;
+
+public class ProperlyClosedLock {
+    private final Lock lock = new ReentrantLock();
+
+    public void doSomething(File file) {
+        InputStream in = null;
+        lock.lock();
+        try {
+            in = new FileInputStream(file);
+            // Perform operations on the open file
+        } catch (FileNotFoundException fnf) {
+            // Forward to handler
+        } finally {
+            lock.unlock();
+            if (in != null) {
+                try {
+                    in.close();
+                } catch (IOException e) {
+                    // Forward to handler
+                }
+            }
+        }
+    }
+}
diff --git a/spotbugsTestCases/src/java/unreleasedLock/ThrowExceptionAndUnlockBeforeLock.java b/spotbugsTestCases/src/java/unreleasedLock/ThrowExceptionAndUnlockBeforeLock.java
new file mode 100644
index 00000000000..949a3481639
--- /dev/null
+++ b/spotbugsTestCases/src/java/unreleasedLock/ThrowExceptionAndUnlockBeforeLock.java
@@ -0,0 +1,33 @@
+package unreleasedLock;
+
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.FileNotFoundException;
+import java.io.IOException;
+import java.io.InputStream;
+import java.util.concurrent.locks.Lock;
+import java.util.concurrent.locks.ReentrantLock;
+
+public class ThrowExceptionAndUnlockBeforeLock {
+    private final Lock lock = new ReentrantLock();
+
+    public void doSomething(File file) {
+        InputStream in = null;
+        try {
+            in = new FileInputStream(file);
+            lock.lock();
+            // Perform operations on the open file
+        } catch (FileNotFoundException fnf) {
+            // Forward to handler
+        } finally {
+            lock.unlock();
+            if (in != null) {
+                try {
+                    in.close();
+                } catch (IOException e) {
+                    // Forward to handler
+                }
+            }
+        }
+    }
+}
diff --git a/spotbugsTestCases/src/java/unreleasedLock/UnreleasedLock.java b/spotbugsTestCases/src/java/unreleasedLock/UnreleasedLock.java
new file mode 100644
index 00000000000..8141943e51e
--- /dev/null
+++ b/spotbugsTestCases/src/java/unreleasedLock/UnreleasedLock.java
@@ -0,0 +1,39 @@
+package unreleasedLock;
+
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.util.concurrent.locks.Lock;
+import java.util.concurrent.locks.ReentrantLock;
+
+public class UnreleasedLock {
+    private final Lock lock = new ReentrantLock();
+
+    public void doSomething(File file) {
+        InputStream in = null;
+        try {
+            in = new FileInputStream(file);
+            lock.lock();
+
+            // Perform operations on the open file
+            byte[] bytes = new byte[10];
+            int a = in.read(bytes);
+            System.out.println("!!!!AFTER READ!!!!");
+            System.out.println(a);
+
+            lock.unlock();
+        } catch (IOException x) {
+            // Handle exception
+        } finally {
+            if (in != null) {
+                try {
+                    in.close();
+                } catch (IOException x) {
+                    // Handle exception
+                }
+
+            }
+        }
+    }
+}
\ No newline at end of file