java中的静态方法怎么调用非静态方法

从一个问题说起

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

对象锁与类锁

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

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

synchronized

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

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

public synchronized static void syncStaticMethod(){

Sy("我是静态方法，我被synchronized修饰。");

}

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

public synchronized void syncMethod(){

Sy("我是非静态方法，我被synchronized修饰。");

}

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

public static void syncStaticBlockMethod() {

synchronized ) {

Sy("我是静态方法，我被synchronized代码块修饰，此时的锁对象是Object的Class对象。");

}

}

public void syncBlockMethod(){

synchronized ){

Sy("我是非静态方法，我被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 {

Sy().getName() + " : 加锁的静态方法运行开始n");

T(3000);

Sy().getName() + " : 加锁的静态方法运行结束");

} catch (InterruptedException e) {

e.printStackTrace();

}

}

public synchronized static void syncStaticYes2() {

try {

Sy().getName() + " : 加锁的静态方法运行开始n");

T(3000);

Sy().getName() + " : 加锁的静态方法运行结束");

} catch (InterruptedException e) {

e.printStackTrace();

}

}

public static void syncStaticNo() {

try {

Sy().getName() + " : 不加锁的静态方法运行开始n");

T(3000);

Sy().getName() + " : 不加锁的静态方法运行结束");

} catch (InterruptedException e) {

e.printStackTrace();

}

}

public synchronized void syncYes() {

try {

Sy().getName() + " : 加锁的非静态方法运行开始n");

T(3000);

Sy().getName() + " : 加锁的非静态方法运行结束");

} catch (InterruptedException e) {

e.printStackTrace();

}

}

public void syncNo() {

try {

Sy().getName() + " : 不加锁的非静态方法运行开始n");

T(3000);

Sy().getName() + " : 不加锁的非静态方法运行结束");

} catch (InterruptedException e) {

e.printStackTrace();

}

}

public static void syncStaticClassYes() {

synchronized ) {

try {

Sy().getName() + " : 加Class对象锁的静态方法运行开始n");

T(3000);

Sy().getName() + " : 加Class对象锁的静态方法运行结束");

} catch (InterruptedException e) {

e.printStackTrace();

}

}

}

public void syncClassYes() {

synchronized ) {

try {

Sy().getName() + " : 加Class对象锁的非静态方法运行开始n");

T(3000);

Sy().getName() + " : 加Class对象锁的非静态方法运行结束");

} catch (InterruptedException e) {

e.printStackTrace();

}

}

}

@Override

public void run() {

if ().getName().equals("Thread-0")) {

syncStaticYes1();

} else if ().getName().equals("Thread-1")) {

syncStaticYes2();

} else if ().getName().equals("Thread-2")) {

syncStaticNo();

} else if ().getName().equals("Thread-3")) {

syncYes();

} else if ().getName().equals("Thread-4")) {

syncNo();

} else if ().getName().equals("Thread-5")) {

syncStaticClassYes();

} else if ().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);

();

();

();

();

();

();

();

}

}

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

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对象锁。