Java并发03---线程技术的死锁

　　我们知道，使用synchronized关键字可以有效的解决线程同步问题，但是如果不恰当的使用synchronized关键字的话也会出问题，即我们所说的死锁。死锁是这样一种情形：多个线程同时被阻塞，它们中的一个或者全部都在等待某个资源被释放。由于线程被无限期地阻塞，因此程序不可能正常终止。
　　下面写一个死锁的例子加深理解。先看程序，再来分析一下死锁产生的原因：

public class DeadLock {

    public static void main(String[] args) {
        Business business = new Business1();
        //开启一个线程执行Business类中的functionA方法
        new Thread(new Runnable() {

            @Override
            public void run() {
                while(true) {
                    business.functionA();
                }
            }
        }).start();

        //开启另一个线程执行Business类中的functionB方法
        new Thread(new Runnable() {

            @Override
            public void run() {
                while(true) {
                    business.functionB();
                }
            }
        }).start();
    }

}

class Business { //定义两个锁，两个方法
    //定义两个锁
    public static final Object lock_a = new Object();
    public static final Object lock_b = new Object();   

    public void functionA() {
        synchronized(lock_a) {
            System.out.println("---ThreadA---lock_a---");
            synchronized(lock_b) {
                System.out.println("---ThreadA---lock_b---");
            }
        }
    }

    public void functionB() {
        synchronized(lock_b) {
            System.out.println("---ThreadB---lock_b---");
            synchronized(lock_a) {
                System.out.println("---ThreadB---lock_a---");
            }
        }
    }
}

　　程序结构很清晰，没什么难度，先看一下程序的执行结果：

—ThreadA—lock_a—
—ThreadA—lock_b—
—ThreadA—lock_a—
—ThreadA—lock_b—
—ThreadA—lock_a—
—ThreadA—lock_b—
—ThreadA—lock_a—
—ThreadB—lock_b—

　　从执行结果来看，线程A跑着跑着，当线程B一跑，啪叽一下就挂了~我们来分析一下原因：从上面的代码中可以看出，定义了一个类Business，该类中维护了两个锁和两个方法，每个方法都是synchronized连环套，并且使用的是不同的锁。好了，现在main方法中开启两个线程A和B，分别执行Business类中的两个方法。A优先执行，跑的很爽，当B线程也开始执行的时候，问题来了，从执行结果的最后两行来看，A线程进入了functionA方法中的第一个synchronized，拿到了lock_a锁，B线程进入了functionB中的第一个synchronized，拿到了lock_b锁，并且两者的锁都还没释放。接下来就是关键了：A线程进入第二个synchronized的时候，发现lock_b正在被B占用，那没办法，它只好被阻塞，等呗~同样地，B线程进入第二个synchronized的时候，发现lock_a正在被A占用，那没办法，它也只好被阻塞，等呗~好了，两个就这样互相等着，你不放，我也不放……死了……
　　上面这个程序对于理解死锁很有帮助，因为结构很好，不过个人感觉这个死的还不过瘾，因为两个线程是实现了两个不同的Runnable接口，只不过调用了同一个类的两个方法而已，因为我把要同步的方法放到一个类中了。下面我把程序改一下，把要同步的代码放到一个Runnable中，让它一运行就挂掉……

public class DeadLock { 

    public static void main(String[] args) {        

        //开启两个线程，分别扔两个自定义的Runnable进去
        new Thread(new MyRunnable(true)).start();;
        new Thread(new MyRunnable(false)).start();;

    }
}

class MyRunnable implements Runnable
{
    private boolean flag; //用于判断，执行不同的同步代码块

    MyRunnable(boolean flag) { //构造方法
        this.flag = flag;
    }

    @Override
    public void run()
    {
        if(flag)
        {
            while(true){            
                synchronized(MyLock.lock_a)
                {
                    System.out.println("--threadA---lock_a--");
                    synchronized(MyLock.lock_b)
                    {
                        System.out.println("--threadA---lock_b--");
                    }   
                }
            }
        }
        else
        {
            while(true){            
                synchronized(MyLock.lock_b)
                {
                    System.out.println("--threadB---lock_a--");
                    synchronized(MyLock.lock_a)
                    {
                        System.out.println("--threadB---lock_b--");
                    }   
                }
            }
        }
    }
}

class MyLock //把两把锁放到一个类中定义，是为了两个线程使用的都是这两把锁
{
    public static final Object lock_a = new Object();
    public static final Object lock_b = new Object();   
}

　　这个死锁就厉害了，一运行，啪叽一下直接就挂掉了……看下运行结果：

–threadA—lock_a–
–threadB—lock_b–

　　以上是死锁的两个例子，都比较容易理解和记忆，主要是“设计模式”不太一样，第一种结构更加清晰，主函数中只要运行逻辑即可，关于同步的部分全扔到Business中，这个便于后期维护，我随便把Business扔到哪去执行都行，因为所有同步的东西都在它自己的类中，这种设计思想很好。第二种是把Runnable先定义好，通过构造方法传进来不同的boolean类型值决定执行run()方法中不同的部分，这种思路也很容易理解，这种死锁更厉害，两个线程直接执行相反的部分，直接挂掉，不给对方一点情面~
　　
　　相关阅读：http://blog.csdn.net/column/details/bingfa.html

Java并发03---线程技术的死锁

猜你喜欢