/* * Copyright (c) 2000 David Flanagan.  All rights reserved. * This code is from the book Java Examples in a Nutshell, 2nd Edition. * It is provided AS-IS, WITHOUT ANY WARRANTY either expressed or implied. * You may study, use, and modify it for any non-commercial purpose. * You may distribute it non-commercially as long as you retain this notice. * For a commercial use license, or to purchase the book (recommended), * visit http://www.davidflanagan.com/javaexamples2. */package com.davidflanagan.examples.thread;/** * This is a demonstration of how NOT to write multi-threaded programs. * It is a program that purposely causes deadlock between two threads that * are both trying to acquire locks for the same two resources. * To avoid this sort of deadlock when locking multiple resources, all threads * should always acquire their locks in the same order. **/public class Deadlock {    public static void main(String[] args) {        // These are the two resource objects we'll try to get locks for        final Object resource1 = "resource1";        final Object resource2 = "resource2";        // Here's the first thread.  It tries to lock resource1 then resource2        Thread t1 = new Thread() {		public void run() {		    // Lock resource 1		    synchronized(resource1) {			System.out.println("Thread 1: locked resource 1");						// Pause for a bit, simulating some file I/O or			// something.  Basically, we just want to give the			// other thread a chance to run.  Threads and deadlock			// are asynchronous things, but we're trying to force			// deadlock to happen here...			try { Thread.sleep(50); }			catch (InterruptedException e) {}						// Now wait 'till we can get a lock on resource 2			synchronized(resource2) {			    System.out.println("Thread 1: locked resource 2");			}		    }		}	    };                // Here's the second thread.  It tries to lock resource2 then resource1        Thread t2 = new Thread() {		public void run() {		    // This thread locks resource 2 right away		    synchronized(resource2) {			System.out.println("Thread 2: locked resource 2");						// Then it pauses, just like the first thread.			try { Thread.sleep(50); }			catch (InterruptedException e) {}						// Then it tries to lock resource1.  But wait!  Thread			// 1 locked resource1, and won't release it 'till it			// gets a lock on resource2.  This thread holds the			// lock on resource2, and won't release it 'till it			// gets resource1.  We're at an impasse. Neither			// thread can run, and the program freezes up.			synchronized(resource1) {			    System.out.println("Thread 2: locked resource 1");			}		    }		}	    };                // Start the two threads. If all goes as planned, deadlock will occur,         // and the program will never exit.        t1.start();         t2.start();    }}