Java示例解决死锁问题

import java.util.*;
import java.util.concurrent.*;
import java.util.concurrent.locks.*;

public class DeadlockDetectingLock extends ReentrantLock {
   private static List deadlockLocksRegistry = new ArrayList();
   private static synchronized void registerLock(DeadlockDetectingLock ddl) {
      if (!deadlockLocksRegistry.contains(ddl)) deadlockLocksRegistry.add(ddl);
   }

   private static synchronized void unregisterLock(DeadlockDetectingLock ddl) {
      if (deadlockLocksRegistry.contains(ddl)) deadlockLocksRegistry.remove(ddl);
   }

   private List hardwaitingThreads = new ArrayList();
   private static synchronized void markAsHardwait(List l, Thread t) {
      if (!l.contains(t)) l.add(t);
   }

   private static synchronized void freeIfHardwait(List l, Thread t) {
      if (l.contains(t)) l.remove(t);
   }

   private static Iterator getAllLocksOwned(Thread t) {
      DeadlockDetectingLock current;
      ArrayList results = new ArrayList();
      Iterator itr = deadlockLocksRegistry.iterator();

      while (itr.hasNext()) {
         current = (DeadlockDetectingLock) itr.next();
         if (current.getOwner() == t)results.add(current);
      }
      return results.iterator();
   }

   private static Iterator getAllThreadsHardwaiting(DeadlockDetectingLock l) {
      return l.hardwaitingThreads.iterator();
   }

   private static synchronized boolean canThreadWaitOnLock (
      Thread t,DeadlockDetectingLock l) {

      Iterator locksOwned = getAllLocksOwned(t);
      while (locksOwned.hasNext()) {
         DeadlockDetectingLock current = (DeadlockDetectingLock) locksOwned.next();
         if (current == l)return false;
         Iterator waitingThreads = getAllThreadsHardwaiting(current);

         while (waitingThreads.hasNext()) {
            Thread otherthread = (Thread) waitingThreads.next();
            if (!canThreadWaitOnLock(otherthread, l)) {
               return false;
            }
         }
      }
      return true;
   }

   public DeadlockDetectingLock() {
      this(false, false);
   }

   public DeadlockDetectingLock(boolean fair) {
      this(fair, false);
   }
   private boolean debugging;

   public DeadlockDetectingLock(boolean fair, boolean debug) {
      super(fair);
      debugging = debug;
      registerLock(this);
   }

   public void lock() {
      if (isHeldByCurrentThread()) {
         if (debugging)
         System.out.println("Already Own Lock");
         super.lock();
         freeIfHardwait(hardwaitingThreads,
         Thread.currentThread());
         return;
      }
      markAsHardwait(hardwaitingThreads, Thread.currentThread());

      if (canThreadWaitOnLock(Thread.currentThread(), this)) {
         if (debugging) System.out.println("Waiting For Lock");
         super.lock();
         freeIfHardwait(hardwaitingThreads, Thread.currentThread());

         if (debugging)System.out.println("Got New Lock");
      } else {
         throw new DeadlockDetectedException("DEADLOCK");
      }
   }

   public void lockInterruptibly() throws InterruptedException {
      lock();
   }

   public class DeadlockDetectingCondition implements Condition {
      Condition embedded;

      protected DeadlockDetectingCondition(ReentrantLock lock, Condition embedded) {
         this.embedded = embedded;
      }

      public void await() throws InterruptedException {
         try {
            markAsHardwait(hardwaitingThreads, Thread.currentThread());
            embedded.await();
         } finally {
            freeIfHardwait(hardwaitingThreads,
            Thread.currentThread());
         }
      }

     public void awaitUninterruptibly() {
         markAsHardwait(hardwaitingThreads, Thread.currentThread());
         embedded.awaitUninterruptibly();
         freeIfHardwait(hardwaitingThreads, Thread.currentThread());
      }

      public long awaitNanos(long nanosTimeout) throws InterruptedException {
         try {
            markAsHardwait(hardwaitingThreads,
            Thread.currentThread());
            return embedded.awaitNanos(nanosTimeout);
         } finally {
            freeIfHardwait(hardwaitingThreads,
            Thread.currentThread());
         }
      }

      public boolean await(long time, TimeUnit unit) throws InterruptedException {
         try {
            markAsHardwait(hardwaitingThreads, Thread.currentThread());
            return embedded.await(time, unit);
         } finally {
            freeIfHardwait(hardwaitingThreads, Thread.currentThread());
         }
      }

      public boolean awaitUntil(Date deadline) throws InterruptedException {
         try {
            markAsHardwait(hardwaitingThreads, Thread.currentThread());
            return embedded.awaitUntil(deadline);
         } finally {
            freeIfHardwait(hardwaitingThreads, Thread.currentThread());
         }
      }

      public void signal() {
         embedded.signal();
      }

      public void signalAll() {
         embedded.signalAll();
      }
   }

   public Condition newCondition() {
      return new DeadlockDetectingCondition(this, super.newCondition());
   }
   private static Lock a = new DeadlockDetectingLock(false, true);
   private static Lock b = new DeadlockDetectingLock(false, true);
   private static Lock c = new DeadlockDetectingLock(false, true);

   private static Condition wa = a.newCondition();
   private static Condition wb = b.newCondition();
   private static Condition wc = c.newCondition();

   private static void delaySeconds(int seconds) {
      try {
         Thread.sleep(seconds * 1000);
      } catch (InterruptedException ex) {}
   }

   private static void awaitSeconds(Condition c, int seconds) {
      try {
         c.await(seconds, TimeUnit.SECONDS);
      } catch (InterruptedException ex) {}
   }

   private static void testOne() {
      new Thread(new Runnable() {
         public void run() {
            System.out.println("thread one grab a");
            a.lock();
            delaySeconds(2);
            System.out.println("thread one grab b");
            b.lock();
            delaySeconds(2);
            a.unlock();
            b.unlock();
         }
      }).start();

      new Thread(new Runnable() {
         public void run() {
            System.out.println("thread two grab b");
            b.lock();
            delaySeconds(2);
            System.out.println("thread two grab a");
            a.lock();
            delaySeconds(2);
            a.unlock();
            b.unlock();
         }
      }).start();
   }

   private static void testTwo() {
      new Thread(new Runnable() {
         public void run() {
            System.out.println("thread one grab a");
            a.lock();
            delaySeconds(2) ;
            System.out.println("thread one grab b");
            b.lock();
            delaySeconds(10);
            a.unlock();
            b.unlock();
         }
      }).start();

      new Thread(new Runnable() {
         public void run() {
            System.out.println("thread two grab b");
            b.lock();
            delaySeconds(2);
            System.out.println("thread two grab c");
            c.lock();
            delaySeconds(10);
            b.unlock();
            c.unlock();
         }
      }).start();

      new Thread(new Runnable() {
         public void run() {
            System.out.println("thread three grab c");
            c.lock();
            delaySeconds(4);
            System.out.println("thread three grab a");
            a.lock();
            delaySeconds(10);
            c.unlock();
            a.unlock();
         }
      }).start();
   }

   private static void testThree() {
      new Thread(new Runnable() {
         public void run() {
            System.out.println("thread one grab b");
            b.lock();
            System.out.println("thread one grab a");
            a.lock();
            delaySeconds(2);
            System.out.println("thread one waits on b");
            awaitSeconds(wb, 10);
            a.unlock();
            b.unlock();
         }
      }).start();

      new Thread(new Runnable() {
         public void run() {
            delaySeconds(1);
            System.out.println("thread two grab b");
            b.lock();
            System.out.println("thread two grab a");
            a.lock();
            delaySeconds(10);
            b.unlock();
            c.unlock();
         }
      }).start();
   }

   public static void main(String args[]) {
      int test = 1;
      if (args.length > 0) test = Integer.parseInt(args[0]);
      switch (test) {
         case 1:
            testOne();
            break;
         case 2:
            testTwo();
            break;
         case 3:
            testThree();
            break;
         default:
            System.err.println("usage: java DeadlockDetectingLock [ test# ]");
      }
      delaySeconds(60);
      System.out.println("--- End Program ---");
      System.exit(0);
   }
}
class DeadlockDetectedException extends RuntimeException {
   public DeadlockDetectedException(String s) {
      super(s);
   }
}