java多线程，静态方法加锁后，调用该方法会影响其它方法吗？
从一个问题说起
一直想要把一些学习历程和感悟记录下来，却没有静下心来好好思考一下，今天，就从同学问到的一个问题开始，对同一个类的静态方法加锁后，调用该方法，其他方法的调用会受到影响吗？
对象锁与类锁
JAVA中每一个对象都持有一把锁–monitor，monitor在操作系统中被称为管程，也可翻译为监视器，java中的monitor其实是对操作系统中monitor的一种实现（类似于接口与实现）。
对象锁和类锁本质其实是一样的，只不过对象锁指的是实例对象（所持有的monitor），而类锁指的是类的Class对象。
synchronized
java中提供synchronized关键字与Object等来实现monitor机制的粒度控制。
synchronized修饰静态方法，此刻的锁指的是实例对象；
public synchronized static void syncStaticMethod(){
System.out.println("我是静态方法，我被synchronized修饰。");
}
synchronized修饰非静态方法，此刻的锁指的是类的Class对象；
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 : 加锁的静态方法运行结束
结论
我们可以看到，不加锁的没有受到任何影响，而加了锁的非静态方法也没有受到任何影响，因为它所竞争的锁并非是Class对象锁，而是实例对象锁，受到影响的有synchronized修饰的静态方法，还有便是加了Class对象锁的方法，本质上便是它们都在竞争当前类的Class对象锁。
