Java-死锁

死锁定义:死锁是指两个或两个以上的进程在执行过程中,由于竞争资源或者由于彼此通信而造成的一种阻塞现象,若无外力作用,它们都将无法推进下去,此时称系统处于死锁状态或系统产生了死锁,这些永远在相互等待的进程称为死锁进程。

例子:哲学家进餐问题

死锁产生的必要条件:

  1. 互斥条件:进程对所分配到的资源不允许其他进程进行访问,若其他进程访问该资源,只能等待,直到占有该资源的进程使用完后释放该资源。
  2. 请求和保持:进程获得一定资源后,可以对其他资源发出获取请求,但同时对自己已经获得的资源保持不放
  3. 不可剥夺条件:进程已经获得的资源,在未完成使用之前,不可以被剥夺,只能在使用完成之后自己释放。
  4. 循环等待:进程发生死锁后,必然存在一个进程-资源之间环形链。

破坏产生死锁的任何一个必要条件都可以消除死锁现象。

写一个简单的死锁程序:

package com.fpc.Test;
class thread1 implements Runnable {
    private DeadLock deadlock;
    
    //构造函数
    public thread1( DeadLock deadlock ) {
        this.deadlock = deadlock;
    }
    
    @Override
    public void run( ) {
        try {
            deadlock.lock1toLock2();
        } catch( Exception e ) {
            e.printStackTrace();
        }
    }
}

class thread2 implements Runnable {
    private DeadLock deadlock;
    
    //构造函数
    public thread2( DeadLock deadlock ) {
        this.deadlock = deadlock;
    }
    
    @Override
    public void run( ) {
        try {
            deadlock.lock2toLock1();
        } catch( Exception e ) {
            e.printStackTrace();
        }
    }
}

public class DeadLock {
    private Object lock1 = new Object();
    private Object lock2 = new Object();
    
    public void lock1toLock2() {
        synchronized( lock1 ) {
            try {
                Thread.sleep(2000);
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
            synchronized( lock2 ) {
                System.out.println("lock1toLock2 end.....");
            }
        }
    }
    
    public void lock2toLock1() {
        synchronized( lock2 ) {
            try {
                Thread.sleep(2000);
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
            synchronized( lock1 ) {
                System.out.println("lock2toLock1 end.....");
            }
        }
    }
    
    public static void main( String[] args ) {
        DeadLock d = new DeadLock();
        thread1 t1 = new thread1(d);
        thread2 t2 = new thread2(d);
        Thread th1 = new Thread(t1);
        Thread th2 = new Thread(t2);
        th1.start();
        th2.start();
    }
}

怎么去分析死锁:

先用jps命令查看虚机中运行的Java线程的pid:

然后根据pid 去查看 jstack pid:

避免死锁的方式

1.设计时考虑清楚锁的顺序,尽量减少嵌套的加锁交互数量

2.死锁产生的原因是资源的循环等待,那么给获取锁加个时间限制,超过一定的时间还没有获取到对象的锁,那么就释放已经获取的对象的锁。当然synchronized是无法做到的,可以用可重入锁ReentrantLock

 

针对上面的程序可以这么改:

public void lock1toLock2() throws InterruptedException {
        if (lock1.tryLock(3000, TimeUnit.MILLISECONDS)){
            try {
                Thread.sleep(2000);
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
            try {
                if ( lock2.tryLock(3000, TimeUnit.MICROSECONDS) ) {
                    System.out.println("lock1toLock2 end.....");
                }
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
      }
    }

运行再次查看jps:可以看到没有出现DeadLock线程了,嗯,不会出现死锁了

 

posted @ 2018-07-04 11:38  起床oO  阅读(161)  评论(0编辑  收藏  举报