Question

I’m trying to learn the basics of java concurrency, I start with oracle java tutorial until http://docs.oracle.com/javase/tutorial/essential/concurrency/deadlock.html, I just add some line to the code example,but when I run the code, the main method never return.
I know that both of alphonseThread and gastonThread are deadlocked by each ether, but why can’t interrupt them from the main Thread?

public class DeadLock {

     static class Freind {

          private final String name;
          public Freind(String name_) {
               this.name = name_;
          }

          public String getName() {
               return this.name;
          }

          public synchronized void bow(Freind bower) throws InterruptedException {
                System.out.format("%s : %s " + "has bowed to me!%n",
                      this.name, bower.getName());
                Thread.sleep(2000);
                bower.bowBack(this);

         }

         public synchronized void bowBack(Freind bower) {
               System.out.format("%s : %s " + "has bowed back to me!%n",
                this.name, bower.getName());
         }
     }

    @SuppressWarnings("SleepWhileInLoop")
    public static void main(String[] args) throws InterruptedException {
        // wait for 4 seconds before send a interuption signal
        int patient = 4000;
        int waitingUnit = 1000;
        long start;
        final Freind alphonse = new Freind("Alphonse");
        final Freind gaston = new Freind("Gaston");
        // the first thread 
        Thread alphonseThread = new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    alphonse.bow(gaston);
                } catch (InterruptedException ex) {
                    System.out.println("Alphnso have been killed");
                }
             }
        });
        // the second thread
        Thread gastonThread = new Thread(new Runnable() {
            @Override
            public void run() {
                 try {
                     gaston.bow(alphonse);
                 } catch (InterruptedException ex) {
                     System.out.println("Gaston have been killed ");
                 }
             }
         });
         // start the tow threads                
         start = System.currentTimeMillis();
         alphonseThread.start();
         gastonThread.start();
         while (alphonseThread.isAlive() || gastonThread.isAlive()) {
             if (((System.currentTimeMillis() - start) < patient)
                     && (alphonseThread.isAlive() || gastonThread.isAlive())) {
                 System.out.println(System.currentTimeMillis() - start);
                 System.out.println("still waiting !!");
                 Thread.sleep(waitingUnit);
              } else {
                 if (alphonseThread.isAlive()) {
                     alphonseThread.interrupt();
                     alphonseThread.join();
                 }
                 if (gastonThread.isAlive()) {
                     gastonThread.interrupt();
                     gastonThread.join();
                }                     
             }
         }
         System.out.println("finnaly I kill all of them");
     }
 }

Answer 1

but why can’t interrupt them from the main Thread?

You can interrupt from the main thread (or anywhere). Just call Thread.interrupt() on the thread you want to interrupt.

The problem is that interrupt won’t unblock a thread that is trying to acquire a Java primitive lock / mutex. In fact, I don’t think there is anything that will safely unblock threads that are deadlocked on primitive locks.

If you want your application to be able to recover from deadlocks involving object locks, then you should probably be using Lock objects, and the Lock.lockInterruptibly() method … which will unblock when the thread is interrupted.