【多线程编程】认识死锁

死锁

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

手动写死锁代码

public class DeadLock {
    private static Object a = new Object();
    private static Object  b= new Object();

    public static void main(String[] args) {
      new Thread(){
          @Override
          public void run() {
              synchronized (a){
                  System.out.println("a lock");
                  try {
                      Thread.sleep(100);
                  } catch (InterruptedException e) {
                      e.printStackTrace();
                  }

                  synchronized (b){
                      System.out.println("b lock");
                  }
              }
          }
      }.start();


        new Thread(){
            @Override
            public void run() {
                synchronized (b){
                    System.out.println("b lock");
                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }

                    synchronized (a){
                        System.out.println("a lock");
                    }
                }
            }
        }.start();
    }
}

输出

  a lock
  b lock

两个线程相互得到锁a、锁b，然后线程1等待线程2释放锁b，而线程2等待线程1释放锁a，两者互不相让，如果没有外力作用，则会形成死锁。

死锁的解决办法

1、按顺序加锁

       上个列子就是两个线程加锁的顺序不一致，导致死锁，如果每个线程都按一个顺序加锁，就不会出现死锁。

public class DeadLock {
    private static Object a = new Object();
    private static Object  b= new Object();

    public static void main(String[] args) {
      new Thread(){
          @Override
          public void run() {
              synchronized (a){
                  System.out.println("a lock");
                  try {
                      Thread.sleep(100);
                  } catch (InterruptedException e) {
                      e.printStackTrace();
                  }

                  synchronized (b){
                      System.out.println("b lock");
                  }
              }
          }
      }.start();


        new Thread(){
            @Override
            public void run() {
                synchronized (a){
                    System.out.println("a lock");
                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }

                    synchronized (b){
                        System.out.println("b lock");
                    }
                }
            }
        }.start();
    }
}

输出

  a lock
  b lock
  a lock
  b lock

2、获取锁时限

       如果每个线程在索取锁的时候，都加上个时限，如果超过这个时间，就放弃锁，就不会产生死锁。

3、死锁检测

      死锁检测是一个更好的死锁预防机制，它主要是针对那些不可能实现按序加锁并且锁超时也不可行的场景。

      根据线程间获取锁的关系检测线程间会不会发生死锁，如果会发生死锁，则执行一定的策略，比如中断线程，回滚操作。