java死锁及其解决方法

死锁

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

举个例子:当一个线程永远地持有一个锁,并且其他线程都尝试获得这个锁时,那么它们将永远被阻塞。比如,线程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)当一个线程进入了一个类的静态同步方法,则其他任何线程都不能进入该类的任何一个静态同步方法。

注意:

  1. 同步的静态方法和非静态方法之间没有关系。也即静态同步方法和非静态同步方法可以同时执行,除非非静态同步方法显式在该类上同步(例如,synchronized(MyClass.class){…})

  2. 类的构造函数不能定义成同步的。

评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值