java多线程中，对同一个类的静态方法加锁后，调用该方法，其他方法的调用会受到影响吗？

从一个问题说起

一直想要把一些学习历程和感悟记录下来，却没有静下心来好好思考一下，今天，就从同学问到的一个问题开始，对同一个类的静态方法加锁后，调用该方法，其他方法的调用会受到影响吗？

对象锁与类锁

java中每一个对象都持有一把锁–monitor，monitor在操作系统中被称为管程，也可翻译为监视器，java中的monitor其实是对操作系统中monitor的一种实现（类似于接口与实现）。

对象锁和类锁本质其实是一样的，只不过对象锁指的是实例对象（所持有的monitor），而类锁指的是类的Class对象。

synchronized

java中提供synchronized关键字与Object等来实现monitor机制的粒度控制。

synchronized修饰静态方法，此刻的锁指的是类的Class对象；

    public synchronized static void syncStaticMethod(){
        System.out.println("我是静态方法，我被synchronized修饰。");
    }

synchronized修饰非静态方法，此刻的锁指的是实例对象；

    public synchronized  void syncMethod(){
        System.out.println("我是非静态方法，我被synchronized修饰。");
    }

synchronized修饰代码块，此刻的锁指的是你所赋予synchronized的对象，与方法是否静态无关；

    public static void syncStaticBlockMethod() {
        synchronized (Object.class) {
            System.out.println("我是静态方法，我被synchronized代码块修饰，此时的锁对象是Object的Class对象。");
        }
    }

    public void syncBlockMethod(){
        synchronized (Object.class){
            System.out.println("我是非静态方法，我被synchronized代码块修饰，此时的锁对象是Object的Class对象。");
        }
    }

分析

那么，对一个类的静态方法加锁，意味着什么？
其实，从上面我们已经可以得到答案了：当这个类的静态方法被调用时，它会去获取类锁，准确的说是该类的Class对象的monitor，那么，其他方法会受到影响吗？在这里，不妨做一个假设，那就是只要其他方法会竞争类的Class对象锁，那么它便会陷入阻塞状态（BLOCKED），直到获取Class对象锁，否则，便没有影响。
当然，最初，我们还是应当使用代码来证明（复制粘贴即可运行），如下：

/**
 * @program: thinking-in-all
 * @description:
 * @author: Lucifinil
 * @create: 2019-12-11
 **/
public class SyncStaticYesAndNo implements Runnable {
    public synchronized static void syncStaticYes1() {
        try {
            System.out.println(Thread.currentThread().getName() + " : 加锁的静态方法运行开始\n");
            Thread.sleep(3000);
            System.out.println(Thread.currentThread().getName() + " : 加锁的静态方法运行结束");
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
    public synchronized static void syncStaticYes2() {
        try {
            System.out.println(Thread.currentThread().getName() + " : 加锁的静态方法运行开始\n");
            Thread.sleep(3000);
            System.out.println(Thread.currentThread().getName() + " : 加锁的静态方法运行结束");
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
    public static void syncStaticNo() {
        try {
            System.out.println(Thread.currentThread().getName() + " : 不加锁的静态方法运行开始\n");
            Thread.sleep(3000);
            System.out.println(Thread.currentThread().getName() + " : 不加锁的静态方法运行结束");
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
    public synchronized void syncYes() {
        try {
            System.out.println(Thread.currentThread().getName() + " : 加锁的非静态方法运行开始\n");
            Thread.sleep(3000);
            System.out.println(Thread.currentThread().getName() + " : 加锁的非静态方法运行结束");
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
    public void syncNo() {
        try {
            System.out.println(Thread.currentThread().getName() + " : 不加锁的非静态方法运行开始\n");
            Thread.sleep(3000);
            System.out.println(Thread.currentThread().getName() + " : 不加锁的非静态方法运行结束");
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
    public static void syncStaticClassYes() {
        synchronized (SyncStaticYesAndNo.class) {
            try {
                System.out.println(Thread.currentThread().getName() + " : 加Class对象锁的静态方法运行开始\n");
                Thread.sleep(3000);
                System.out.println(Thread.currentThread().getName() + " : 加Class对象锁的静态方法运行结束");
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
    public void syncClassYes() {
        synchronized (SyncStaticYesAndNo.class) {
            try {
                System.out.println(Thread.currentThread().getName() + " : 加Class对象锁的非静态方法运行开始\n");
                Thread.sleep(3000);
                System.out.println(Thread.currentThread().getName() + " : 加Class对象锁的非静态方法运行结束");
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
    @Override
    public void run() {
        if (Thread.currentThread().getName().equals("Thread-0")) {
            syncStaticYes1();
        } else if (Thread.currentThread().getName().equals("Thread-1")) {
            syncStaticYes2();
        } else if (Thread.currentThread().getName().equals("Thread-2")) {
            syncStaticNo();
        } else if (Thread.currentThread().getName().equals("Thread-3")) {
            syncYes();
        } else if (Thread.currentThread().getName().equals("Thread-4")) {
            syncNo();
        } else if (Thread.currentThread().getName().equals("Thread-5")) {
            syncStaticClassYes();
        } else if (Thread.currentThread().getName().equals("Thread-6")) {
            syncClassYes();
        }
    }
    public static void main(String[] args) {
        SyncStaticYesAndNo obj = new SyncStaticYesAndNo();
        Thread t1 = new Thread(obj);
        Thread t2 = new Thread(obj);
        Thread t3 = new Thread(obj);
        Thread t4 = new Thread(obj);
        Thread t5 = new Thread(obj);
        Thread t6= new Thread(obj);
        Thread t7 = new Thread(obj);
        t1.start();
        t2.start();
        t3.start();
        t4.start();
        t5.start();
        t6.start();
        t7.start();
    }
}

这里，我们使用了七个线程来模拟多个情况，然后几乎同时调用七个方法，由之前的分析，我们可以推测，只有竞争统一把锁，才会产生阻塞情况，所以结果如下：

Thread-1 : 加锁的静态方法运行开始

Thread-3 : 加锁的非静态方法运行开始

Thread-2 : 不加锁的静态方法运行开始

Thread-4 : 不加锁的非静态方法运行开始

Thread-3 : 加锁的非静态方法运行结束
Thread-1 : 加锁的静态方法运行结束
Thread-2 : 不加锁的静态方法运行结束
Thread-6 : 加Class对象锁的非静态方法运行开始

Thread-4 : 不加锁的非静态方法运行结束
Thread-6 : 加Class对象锁的非静态方法运行结束
Thread-5 : 加Class对象锁的静态方法运行开始

Thread-5 : 加Class对象锁的静态方法运行结束
Thread-0 : 加锁的静态方法运行开始

Thread-0 : 加锁的静态方法运行结束

结论

我们可以看到，不加锁的没有受到任何影响(不加锁的方法线程与Thread-1几乎是同时开始运行与结束)，而加了锁的非静态方法也没有受到任何影响(与Thread-1几乎是同时开始运行与结束)，因为它所竞争的锁并非是Class对象锁，而是实例对象锁，受到影响的有synchronized修饰的静态方法，还有便是加了Class对象锁的方法(必须等待持有Class对象锁的线程执行结束后才能开始执行)，本质上便是它们都在竞争当前类的Class对象锁。

后记

原文地址，如果有不正确的地方，欢迎大家批评指正，共同进步。