Löscht ein Thread eine Sperre, wenn es fertig ist?

Question

Ich habe an Orten gelesen, dass es keine gute Programmierpraxis ist, ein Lock Objekt zu erwerben, ohne dass der folgende Code in einem try...finally Block enthalten ist, so dass das Schloss selbst dann ausgelöst werden kann, wenn eine Ausnahme ausgelöst wird.

Es klingt vielleicht wie eine einfache Frage: Werden alle zu einem Thread gehörenden Sperren automatisch freigegeben, wenn der Thread fertig ist?

Der Grund, warum ich diese Frage stelle, ist, dass das Programm, an dem ich arbeite, so ist, dass sobald ein Thread eine Sperre erwirbt, es keinen Grund haben sollte, bis es beendet ist. Außerdem bin ich neu in der Verwendung von Sperren, also frage ich mich, ob es irgendwelche Fallstricke gibt, die ich vielleicht nicht berücksichtigt habe. Muss ich mir Sorgen darüber machen, dass Sperren explizit in meinem Code freigegeben werden, bevor der Thread beendet wird, oder kann ich es der JVM überlassen, da ich sicher bin, dass andere Threads, die auf allen Sperren des aktiven Threads blockiert sind, sofort aktiviert werden Faden stoppt?

Answer 1

Einfacher Test können Ihnen diese Sperre zeigt, ist nicht auf Threadbeendigung freigegeben:

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

public class LockTest { 
    public static void main(String[] args) { 
     final Lock l = new ReentrantLock(); 

     Thread t = new Thread() { 
      @Override 
      public void run() { 
       System.out.println(Thread.currentThread()+": Acquire lock"); 
       l.lock(); 
       System.out.println(Thread.currentThread()+": Lock aquired: wait"); 
       LockSupport.parkNanos(1_000_000_000); 
       System.out.println(Thread.currentThread()+"; Exiting"); 
      } 
     }; 
     t.start(); 
     LockSupport.parkNanos(500_000_000); 
     System.out.println(Thread.currentThread()+": Acquire lock"); 
     l.lock(); 
     System.out.println(Thread.currentThread()+"; Success!"); 
    } 
} 

Ausgang:

Thread[Thread-0,5,main]: Acquire lock 
Thread[Thread-0,5,main]: Lock aquired: wait 
Thread[main,5,main]: Acquire lock 
Thread[Thread-0,5,main]; Exiting 
// "Success" is never written: stuck in dead-lock 

Also, wenn der separate Thread die Sperre erworben, dann verlassen, Schloss kann nicht genommen werden, nach Hauptthread.