Lock ChangeSet (fin): Cleanup, fix and enhance RecursiveLock implementation

- RecursiveLock _is_ interface.

- Use LockFactory to create a RecursiveLock.

- Impl: RecursiveLockImpl01Unfairish
  - just using notify w/o any queue: fast
  - still enqueuing new lock-applicants if queue full (nice)
  - lock's sync extends AbstractOwnableSynchronizer and uses it (monitor)

- Impl: RecursiveLockImpl01CompleteFair
  - using queue and interrupt for correctness (slow)
  - lock's sync extends AbstractOwnableSynchronizer and uses it (monitor)

- Impl: RecursiveLockImplJava5 for using Java5's concurrency impl.
  - to verify correctness, performance and deviation of locking time

TestRecursiveLock01 new performance measurements incl. simple avrg and deviation
shows best combined performance-deviation w/ our RecursiveLockImpl01Unfairish
os Linux and MacOSX.
RecursiveLockImpl01Unfairish is the default in LockFactory.

Adding 'private' LockDebugUtil, allowing validating all holdings locks
of one thread as stack traces (Throwable).
Besides the AbstractOwnableSynchronizer utilization, this helps debugging deadlocks
and starvation very well.

1 files changed, 81 insertions, 0 deletions

diff --git a/src/java/jogamp/common/util/locks/RecursiveLockImplJava5.java b/src/java/jogamp/common/util/locks/RecursiveLockImplJava5.java
new file mode 100644
index 0000000..b4e6ce0
--- /dev/null
+++ b/src/java/jogamp/common/util/locks/RecursiveLockImplJava5.java
@@ -0,0 +1,81 @@
+package jogamp.common.util.locks;
+
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.locks.ReentrantLock;
+
+import com.jogamp.common.util.locks.RecursiveLock;
+
+public class RecursiveLockImplJava5 implements RecursiveLock {
+
+    volatile Thread owner = null;
+    ReentrantLock lock;
+    
+    public RecursiveLockImplJava5(boolean fair) {
+        lock = new ReentrantLock(fair);
+    }
+    
+    public void lock() {
+        try {
+            if(!tryLock(TIMEOUT)) {
+                throw new RuntimeException("Waited "+TIMEOUT+"ms for: "+threadName(owner)+" - "+threadName(Thread.currentThread())+", with count "+getHoldCount()+", lock: "+this);
+            }
+        } catch (InterruptedException e) {
+            throw new RuntimeException("Interrupted", e);
+        }
+        owner = Thread.currentThread();
+    }
+
+    public boolean tryLock(long timeout) throws InterruptedException {
+        if(lock.tryLock(timeout, TimeUnit.MILLISECONDS)) {
+            owner = Thread.currentThread();
+            return true;
+        }
+        return false;
+    }
+
+    public void unlock() throws RuntimeException {
+        validateLocked();
+        owner = null;
+        lock.unlock();
+    }
+
+    public boolean isLocked() {
+        return lock.isLocked();
+    }
+
+    public Thread getOwner() {
+        return owner;
+    }
+
+    public boolean isLockedByOtherThread() {
+        return lock.isLocked() && !lock.isHeldByCurrentThread();
+    }
+
+    public boolean isOwner() {
+        return lock.isHeldByCurrentThread();
+    }
+
+    public boolean isOwner(Thread thread) {
+        return lock.isLocked() && owner == thread;
+    }
+
+    public void validateLocked() {
+        if ( !lock.isHeldByCurrentThread() ) {
+            if ( !lock.isLocked() ) {
+                throw new RuntimeException(Thread.currentThread()+": Not locked");
+            } else {
+                throw new RuntimeException(Thread.currentThread()+": Not owner, owner is "+owner);
+            }
+        }
+    }
+
+    public int getHoldCount() {
+        return lock.getHoldCount();
+    }
+
+    public int getQueueLength() {
+        return lock.getQueueLength();
+    }
+
+    private String threadName(Thread t) { return null!=t ? "<"+t.getName()+">" : "<NULL>" ; }
+}