java死锁及其解决方法

最新推荐文章于 2024-08-05 13:14:43 发布

林头头03

最新推荐文章于 2024-08-05 13:14:43 发布

阅读量2.2k

点赞数

分类专栏：编程语言

本文链接：https://blog.csdn.net/qq_29373285/article/details/81411523

版权

编程语言专栏收录该内容

33 篇文章 7 订阅

订阅专栏

死锁

通俗点讲：死锁就是两个或两个以上的进程或线程在执行过程中，由于竞争资源或者由于彼此通信而造成的一种阻塞的现象，若无外力作用，它们都将无法推进下去。

举个例子：当一个线程永远地持有一个锁，并且其他线程都尝试获得这个锁时，那么它们将永远被阻塞。比如，线程1已经持有了A锁并想要获得B锁的同时，线程2持有B锁并尝试获取A锁，那么这两个线程将永远地等待下去。

再用简单一点的例子来说吧

比如这个交通堵塞的例子，从图中可以看到四个方向行驶的汽车互相阻塞，如果没有任何一个方向的汽车退回去，那么将形成一个死锁

上述图中有产生死锁的四个原因：

1.互斥条件：一个资源每次只能被一个线程使用。图上每条路上只能让一个方向的汽车通过，故满足产生死锁的条件之一

2.请求与保持条件：一个进程因请求资源而阻塞时，对已获得的资源保持不放。可以看出，图上每个方向的汽车都在等待其他方向的汽车撤走，故满足产生死锁的条件之二

3.不剥夺条件：进程已获得的资源，在未使用完之前，不能强行剥夺。这里假设没有交警，那么没有人能强行要求其他方向上的汽车撤离，故满足产生死锁的条件之三

4.循环等待条件：若干进程或线程之间形成一种头尾相接的循环等待资源关系。这个在图中很直观地表达出来了

死锁的解决方案：

1.打破互斥条件，我们需要允许进程同时访问某些资源，这种方法受制于实际场景，不太容易实现条件；

2.打破不可抢占条件，这样需要允许进程强行从占有者那里夺取某些资源，或者简单一点理解，占有资源的进程不能再申请占有其他资源，必须释放手上的资源之后才能发起申请，这个其实也很难找到适用场景；

3. 进程在运行前申请得到所有的资源，否则该进程不能进入准备执行状态。这个方法看似有点用处，但是它的缺点是可能导致资源利用率和进程并发性降低

4. 避免出现资源申请环路，即对资源事先分类编号，按号分配。这种方式可以有效提高资源的利用率和系统吞吐量，但是增加了系统开销，增大了进程对资源的占用时间。

使用多线程的时候，一种非常简单的避免死锁的方式就是：==指定获取锁的顺序==，并强制线程按照指定的顺序获取锁。因此，如果所有的线程都是以同样的顺序加锁和释放锁，就不会出现死锁了。

（1）. 最简单、最常用的方法就是进行系统的重新启动，不过这种方法代价很大，它意味着在这之前所有的进程已经完成的计算工作都将付之东流，包括参与死锁的那些进程，以及未参与死锁的进程；

（2）. 撤消进程，剥夺资源。终止参与死锁的进程，收回它们占有的资源，从而解除死锁。这时又分两种情况：一次性撤消参与死锁的全部进程，剥夺全部资源；或者逐步撤消参与死锁的进程，逐步收回死锁进程占有的资源。一般来说，选择逐步撤消的进程时要按照一定的原则进行，目的是撤消那些代价最小的进程，比如按进程的优先级确定进程的代价；考虑进程运行时的代价和与此进程相关的外部作业的代价等因素；

（3）. 进程回退策略，即让参与死锁的进程回退到没有发生死锁前某一点处，并由此点处继续执行，以求再次执行时不再发生死锁。虽然这是个较理想的办法，但是操作起来系统开销极大，要有堆栈这样的机构记录进程的每一步变化，以便今后的回退，有时这是无法做到的。

package deadlock;
public class DeadlockSample {
	
	//必须有两个可以被加锁的对象才能产生死锁，只有一个不会产生死锁问题
    private final Object obj1 = new Object();
    private final Object obj2 = new Object();
 
    public static void main(String[] args) {
        DeadlockSample test = new DeadlockSample();
        test.testDeadlock();
    }
 
    private void testDeadlock() {
        Thread t1 = new Thread(new Runnable() {
            public void run() {
                calLock_Obj1_First();
            }
        });
        Thread t2 = new Thread(new Runnable() {
            public void run() {
            	calLock_Obj2_First();
            }
        });
        t1.start();
        t2.start();
    }
    
    //先synchronized  obj1，再synchronized  obj2
    private void calLock_Obj1_First() {
        synchronized (obj1) {
            sleep();
            synchronized (obj2) {
                sleep();
            }
        }
    }
    
  //先synchronized  obj2，再synchronized  obj1
    private void calLock_Obj2_First() {
        synchronized (obj2) {
            sleep();
            synchronized (obj1) {
                sleep();
            }
        }
    }
    
    /**
     * 为了便于让两个线程分别锁住其中一个对象，
     * 一个线程锁住obj1，然后一直等待obj2，
     * 另一个线程锁住obj2，然后一直等待obj1，
     * 然后就是一直等待，死锁产生
     */
    private void sleep() {
        try {
            Thread.sleep(100);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

带着问题考虑java同步的问题：

同步

在多线程程序中，同步修饰符用来控制对临界区代码的访问。其中一种方式是用synchronized关键字来保证代码的线程安全性。在Java中，synchronized修饰的代码块或方法不会被多个线程并发访问。它强制要求线程在进入一个方法之前获得一个锁，在离开方法时释放该锁。它保证了在同一时刻只有一个线程能执行被其修饰的方法。

如果我们把一个方法或代码块定义为同步的，就意味着在同一个对象中，只会有一个对同步方法的调用。如果在一个线程内部调用了一个同步方法，则其他线程会一直阻塞，直到第一个线程完成方法调用。

在进入一个对象的同步方法之前，需要申请对该对象上锁，完成方法调用后释放锁供其他线程申请。同步方法遵循happens-before机制，它保证了对象状态的改变在其他线程中都是可见的。

当标记一个代码块为同步时，需要用一个对象作为参数。当一个运行线程执行到该代码块时，要等到其他运行线程退出这个对象的同步代码区。然而，一个线程可以进入另一个对象的同步代码区。但是同一个对象的非同步方法可以不用申请锁。

如果定义一个静态方法为同步，则是在类上同步，而不是在对象上同步。也即如果一个静态同步方法在执行时，整个类被锁住，对该类中的其他静态方法调用会阻塞。

1）当一个线程进入了一个实例的同步方法，则其他任何线程都不能进入该实例的任何一个同步方法。

2）当一个线程进入了一个类的静态同步方法，则其他任何线程都不能进入该类的任何一个静态同步方法。

注意：