解锁其他线程拥有的锁java

Question

我有一个LockManager管理多个线程的锁。有时线程是坏男孩，我必须杀死它们并要求LockManager释放所有的锁。然而，因为我在java中使用ReentrantLock这是不可能的，我不能解锁另一个线程拥有的锁。

我被迫使用锁（不能使用信号灯，它是作业的一部分）。有没有任何Java Lock实现允许我解锁其他线程拥有的锁？

到目前为止，我认为有三种选择：

• 重新实施的方式，让我做这件事
• 使信号灯和ReentrantLocks

额外之间某种映射的ReentrantLock您可能会觉得有用的来源：

• Reentrant locks - Unlocking from another thread
• Unlocking a lock from a thread which doesn't own it, or redesigning to avoid this?

Answer 1

你是否被允许使用自己的Lock？这里有一个完全代理Lock的类，但是当它被告知强制解锁时，它只是用一个替代它代理的锁。这应该有你想要的效果。可悲的是，它仍然没有处理那些悬而未决的锁，但现在成为别人的问题。你的锁现在神奇地解锁。

static class LockProxy<L extends Lock> implements Lock { 

    // The actual lock. 
    private volatile Lock lock; 

    public LockProxy(L lock) { 
     // Trap the lock we are proxying. 
     this.lock = lock; 
    } 

    @Override 
    public void lock() { 
     // Proxy it. 
     lock.lock(); 
    } 

    @Override 
    public void lockInterruptibly() throws InterruptedException { 
     // Proxy it. 
     lock.lockInterruptibly(); 
    } 

    @Override 
    public boolean tryLock() { 
     // Proxy it. 
     return lock.tryLock(); 
    } 

    @Override 
    public boolean tryLock(long l, TimeUnit tu) throws InterruptedException { 
     // Proxy it. 
     return lock.tryLock(l, tu); 
    } 

    @Override 
    public void unlock() { 
     // Proxy it. 
     lock.unlock(); 
    } 

    @Override 
    public Condition newCondition() { 
     // Proxy it. 
     return lock.newCondition(); 
    } 

    // Extra functionality to unlock from any thread. 
    public void forceUnlock() { 
     // Actually just replace the perhaps locked lock with a new one. 
     // Kinda like a clone. I expect a neater way is around somewhere. 
     if (lock instanceof ReentrantLock) { 
      lock = new ReentrantLock(); 
     } else { 
      throw new UnsupportedOperationException(
       "Cannot force unlock of lock type " 
        + lock.getClass().getSimpleName()); 
     } 
    } 
} 

Answer 2

你已经发现了一个重要的原因共同智慧说：不要杀线程！

锁只是强制杀死线程时可能发生的潜在资源泄漏之一。考虑打开的文件和套接字等。

还要考虑到，如果你确实设法解锁了锁，那么原因锁就是锁定在第一位。例如，线程可能已经部分更新了一个数据结构，并且允许从另一个线程访问该结构可能会导致奇怪且令人惊奇的程序故障，如果不是无法进行调试，则该故障很难。

处理这种情况的最好方法是要求线程消失。为与线程关联的对象添加一个“stop（）”方法（每个线程都有一个对象，不是吗？），它会设置一个标志，并让线程定期检查该标志，并在设置时退出。

如果你的线程行为异常，阻止他们检查停止标志，那么正确的方法是修复代码，以免它行为不当。

Answer 3

你为什么不干脆换你的线程的代码围绕以下：

ReentrantLock lock = ... obtain your lock somehow ... 
lock.lock(); 
try { 
    ... the "bad boy" code here ... 
} finally { 
    lock.unlock(); 
} 

然后，当你的线程结束（或者通过正常完成，或者从您的“杀”抛出一个异常） ，它会释放锁。

其实，这是Oracle建议使用的ReentrantLock方式：http://docs.oracle.com/javase/7/docs/api/java/util/concurrent/locks/ReentrantLock.html