Java并发编程-各种锁，java高级面试笔试题

我总结出了很多互联网公司的面试题及答案，并整理成了文档，以及各种学习的进阶学习资料，免费分享给大家。
扫描二维码加VX好友，拉你进【程序员面试学习交流群】免费领取。也欢迎各位一起在群里探讨技术。

 

安全性和活跃度通常相互牵制。我们使用锁来保证线程安全，但是滥用锁可能引起锁顺序死锁。类似地，我们使用线程池和信号量来约束资源的使用，

 

但是缺不能知晓哪些管辖范围内的活动可能形成的资源死锁。Java应用程序不能从死锁中恢复，所以确保你的设计能够避免死锁出现的先决条件是非常有价值。

一.死锁

经典的“哲学家进餐”问题很好的阐释了死锁。5个哲学家一起出门去吃中餐，他们围坐在一个圆桌边。他们只有五只筷子(不是5双)，每两个人中间放有一只。

哲学家边吃边思考，交替进行。每个人都需要获得两只筷子才能吃东西，但是吃后要把筷子放回原处继续思考。有一些管理筷子的算法，使每一个人都能够或多或少，及时

吃到东西(一个饥饿的哲学家试图获得两只临近的筷子，但是如果其中的一只正在被别人占用，那么他英爱放弃其中一只可用的筷子，等待几分钟再尝试)。但是这样做可能导致

一些哲学家或者所有哲学家都饿死 (每个人都迅速捉住自己左边的筷子，然后等待自己右边的筷子变成可用，同时并不放下左边的筷子)。这最后一种情况，当每个人都拥有他人需要的

资源，并且等待其他人正在占有的资源，如果大家一致占有资源，直到获得自己需要却没占有的其他资源，如果大家一致占有资源，直到获得自己需要却没被占有的其他资源，那么就会产生死锁。

当一个线程永远占有一个锁，而其他线程尝试去获得这个锁，那么他们将永远被阻塞。当线程Thread1占有锁A时，想要获得锁B，但是同时线程Thread2持有B锁，并尝试获得A锁，两个线程将永远等待下去。

这种情况是死锁最简单的形式.

例子如下代码：

 

public class DeadLock {

    private static Object lockA = new Object();

    private static Object lockB = new Object();

    public static void main(String[] args) {

        new DeadLock().deadLock();

    }

    private void deadLock() {

        Thread thread1 = new Thread(new Runnable() {

            public void run() {

                synchronized (lockA){

                    try {

                        System.out.println(Thread.currentThread().getName() + "获取A锁 ing！");

                        Thread.sleep(500);

                        System.out.println(Thread.currentThread().getName() + "睡眠500ms");

                    } catch (Exception e) {

                        e.printStackTrace();

                    }

                    System.out.println(Thread.currentThread().getName() + "需要B锁！！！");

                    synchronized (lockB){

                        System.out.println(Thread.currentThread().getName() + "B锁获取成功");

                    }

                }

            }

        },"Thread1");

        Thread thread2 = new Thread(new Runnable() {

            public void run() {

                synchronized (lockB){

                    try {

                        System.out.println(Thread.currentThread().getName() + "获取B锁 ing！");

                        Thread.sleep(500);

                        System.out.println(Thread.currentThread().getName() + "睡眠500ms");

                    } catch (Exception e) {

                        e.printStackTrace();

                    }

                    System.out.println(Thread.currentThread().getName() + "需要A锁！！！");

                    synchronized (lockA){

                        System.out.println(Thread.currentThread().getName() + "A锁获取成功");

                    }

                }

            }

        },"Thread2");

        thread1.start();

        thread2.start();

    }

}

 

运行结果如下图：

结果很明显了，这两个线程陷入了死锁状态了，发生死锁的原因是，两个线程试图通过不同的顺序获得多个相同的锁。如果请求锁的顺序相同，

就不会出现循环的锁依赖现象(你等我放锁，我等你放锁)，也就不会产生死锁了。如果你能够保证同时请求锁A和锁B的每一个线程，都是按照从锁A到锁B的顺序，那么就不会发生死锁了。

如果所有线程以通用的固定秩序获取锁，程序就不会出现锁顺序死锁问题了。

什么情况下会发生死锁呢？

1.锁的嵌套容易发生死锁。解决办法：获取锁时，查看是否有嵌套。尽量不要用锁的嵌套，如果必须要用到锁的嵌套，就要指定锁的顺序，因为参数的顺序是超乎我们控制的，为了解决这个问题，我们必须指定锁的顺序，并且在整个应用程序中，

获得锁都必须始终遵守这个既定的顺序。

上面的例子出现死锁的根本原因就是获取所的顺序是乱序的，超乎我们控制的。上面例子最理想的情况就是把业务逻辑抽离出来，把获取锁的代码放在一个公共的方法里面，让这两个线程获取锁

都是从我的公共的方法里面获取，当Thread1线程进入公共方法时，获取了A锁，另外Thread2又进来了，但是A锁已经被Thread1线程获取了，Thread1接着又获取锁B，Thread2线程就不能再获取不到了锁A，更别说再去获取锁B了，这样就有一定的顺序了。

上面例子的改造如下&#