JUC并发系列(三)：面试问并发，一问锁懵了（怒肝一篇透彻理解锁，面试不慌）

跑起一个程序，并不难；难的是，能让程序跑多远！—— 一颗剽悍的种子

JUC并发系列

JUC并发系列(一)：什么？听说你搞混了并发和并行
JUC并发系列(二)：详解Condition实现精准通知唤醒

锁的存在是多线程与并发的核心，只有透彻理解锁，邂逅面试不慌，也能在实际工作中对处理并发问题 随薪锁欲 随心所欲。

一、多个同步方法执行顺序由谁决定

通常情况下，两个线程的执行顺序并不是由先后顺序（自上而下）执行的，而是有锁的存在，用了同一把锁后，才按顺序先后执行。

这里锁的是同一个对象的锁，computer对象的锁，所以谁在前，谁先执行。

Computer computer = new Computer();

1.1手敲代码实现

这里我们写了两个方法（锁了两个方法，也就是同步方法），一个是学习，一个是打游戏。

public class Demo{
    public static void main(String[] args) {
        Computer computer = new Computer();

        new Thread(()->{
            computer.study();
        },"a").start();

        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        new Thread(()->{
            computer.game();
        },"b").start();
    }
}
class Computer{

    public synchronized void study(){
        try {
            TimeUnit.SECONDS.sleep(5);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("学习");
    }
    public synchronized void game(){
        System.out.println("打游戏");
    }
}

运行结果

可以看到谁在前，谁先执行，所以顺序也是先学习，后游戏。

二、多个对象里的同步方法

多个对象锁的同步方法执行顺序依然，但是不同于一个对象锁，多个对象锁会因为休眠时间而影响执行顺序。

2.1手敲代码实现

在上面的代码，我们只锁了一个对象，那么接下增加多一个对象锁，两个对象，同样两个方法，你还会不会回答是先学习后游戏呢？

public class Demo{
    public static void main(String[] args) {
        Computer computer1 = new Computer();
        Computer computer2 = new Computer();

        new Thread(()->{
            computer1.study();
        },"a").start();

        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        new Thread(()->{
            computer2.game();
        },"b").start();


    }
}
class Computer{

    public synchronized void study(){
        try {
            TimeUnit.SECONDS.sleep(4);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("学习");
    }
    public synchronized void game(){
        System.out.println("打游戏");
    }
}

运行结果

正确答案是：先打游戏，然后是学习。

三.同步方法与非同步方法

同步方法与非同步方法不同之处在于，非同步方法不受锁的影响。

3.1手敲代码实现

在上面1.1的代码中，我们增加了一个看电影的非同步方法（普通方法），我们可以来验证一下执行的顺序。

 public void movie(){
        System.out.println("看电影");
    }

public class Demo{
    public static void main(String[] args) {
        Computer computer = new Computer();

        new Thread(()->{
            computer.study();
        },"a").start();

        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        new Thread(()->{
            computer.game();
        },"b").start();

        new Thread(()->{
            computer.movie();
        },"c").start();
    }
}
class Computer{

    public synchronized void study(){
        try {
            TimeUnit.SECONDS.sleep(5);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("学习");
    }
    public synchronized void game(){
        System.out.println("打游戏");
    }

    public void movie(){
        System.out.println("看电影");
    }
}

运行结果

四、静态同步方法

在之前这篇中深入浅出Java内部类，我们谈过static是最先执行，在加载字节码就会自动调用，而且在主方法main之前，比构造方法早，此时非static属性和方法还没有完成初始化呢。

超详细深入浅出Java内部类

static静态方法在类一加载就有了，所以锁的class本身，也就是锁的是同一个对象。

4.1手敲代码实现

我们依然创建两个对象锁，但是不同的是我们的方法都加了static变成静态方法，来看看执行的顺序。

public class Demo{
    public static void main(String[] args) {
        Computer computer = new Computer();

        new Thread(()->{
            computer.study();
        },"a").start();

        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        new Thread(()->{
            computer.game();
        },"b").start();
    }
}
class Computer{

    public static synchronized void study(){
        try {
            TimeUnit.SECONDS.sleep(5);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("学习");
    }
    public static synchronized void game(){
        System.out.println("打游戏");
    }
}

运行结果

五、静态同步方法与普通同步方法对比

如果你理解了上面的静态同步方法，相信你也理解能理解静态同步方法与普通同步方法的区别。

static静态同步方法锁的是class类，而普通同步方法锁的是调用，所以是两个不同的锁。

理解了这段话，你也理解了代码，以及输出的结果。

5.1手敲代码实现

下面的代码同样创建一个对象，还是两个方法，不同的是这次输出学习是静态同步方法，而输出打游戏是普通方法，如果你能理解

public class Demo{
    public static void main(String[] args) {
        Computer computer = new Computer();
        new Thread(()->{
            computer.study();
        },"a").start();

        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        new Thread(()->{
            computer.game();
        },"b").start();
    }
}
class Computer{

    public static synchronized void study(){
        try {
            TimeUnit.SECONDS.sleep(5);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("学习");
    }
    public synchronized void game(){
        System.out.println("打游戏");
    }
}

运行结果

可以看到静态同步方法和普通同步方法两个不同的锁，如果在没有休眠的情况下，静态同步方法是优先执行的，因为在类加载时就调用（重要的事情，说无数遍），但是但是，在有休眠延时的情况下，因为延时我们的普通方法先执行了；

记住静态同步方法和普通方法锁的不是同一个，前者是class类，而后者是调用者。

六、最后

最后的最后，为了更好的阅读体验，我把想说的话都放在了下面，嘿嘿。

我是一颗剽悍的种子 把我会的，认真的分享 是我写博客一直不变的信条。
如果你能看到这篇博文，说明咱们还是很有缘的；希望能带给你一些许帮助，创作的不易， 把我文章的知识带走，你的三连留下，点赞，评论，关注，是我最大的动力。