DeadLock (synchronized）java中死锁的例子

DeadLock (synchronized)

举例：

两把锁（嵌套），两个线程，相互等待钥匙，但是都等不到。

例如：

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";

        int a=0;

        // 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) {

                           while(true){

                            System.out.println("Thread 1: locked resource 2");

                            try { Thread.sleep(10000); }

                            catch (InterruptedException e) {  }

                           }

                        }

                    }

                }

            };

       

        // 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( );

    }

}

 

评论

1 楼 luzl 2008-11-18  

兄弟写的很有用，我的理解是这样的:
第一步：
    t1启动锁定resource1

synchronized(resource1)

，然后进入睡眠.
    t2启动锁定resource2

synchronized(resource1)

，然后进入睡眠.
第二步:
    t1去使用resource2，但是resource2的锁已经被t2占用，所以会等待.
    t2去使用resource1，但是resource1的锁已经被t1占用，所以发生死锁.

能够发生死锁的两个必要条件是:synchronized,sleep.