不就是锁吗怎么还这么细分，好吧得查资料看看
synchronized关键字的用法主要有以下几种：
1.作用在非静态方法上
非静态方法是只能提供类的实例进行调用，所以实际上就是对调用方法的对象加锁，俗称对象锁
2.作用在静态方法上
静态方法是可以通过类名直接调用，所以实际上就是对调用方法的类加锁，俗称类锁
3.作用在代码块
根据传入的是类对象或类实例判断加锁方式
场景分析
public class SyncStaticClazz {
public static synchronized void method1(){
System.out.println("static ----method1----"+Thread.currentThread());
try {
Thread.sleep(2000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
public static synchronized void method2(){
System.out.println("static ----method2----"+Thread.currentThread());
try {
Thread.sleep(2000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
public synchronized void method3(){
System.out.println("unstatic ----method3----"+Thread.currentThread());
try {
Thread.sleep(2000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
public class SyncClazz {
public synchronized void method1(){
System.out.println("normal----method1----"+Thread.currentThread());
try {
Thread.sleep(2000);
} catch (InterruptedException e) {
System.out.println(e.getMessage());
e.printStackTrace();
}
}
public synchronized void method2()
System.out.println("normal----method2----" + Thread.currentThread());
try {
Thread.sleep(2000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
public void method3() {
synchronized (SyncClazz.class) {
System.out.println("normal----method3----" + Thread.currentThread());
try {
Thread.sleep(2000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
public void method4() {
synchronized (SyncClazz.this) {
System.out.println("normal----method4----" + Thread.currentThread());
try {
Thread.sleep(2000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
public void method5() {
synchronized (SyncClazz.class) {
System.out.println("normal----method5----" + Thread.currentThread());
try {
Thread.sleep(2000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
场景1
new Thread(new Runnable() {
@Override
public void run() {
SyncStaticClazz.method1();
}
}).start();
new Thread(new Runnable() {
@Override
public void run() {
SyncStaticClazz.method2();
}
}).start();
结果：互斥
解析：静态同步方法的加锁范围是整个类，所以无论是使用对象或类去访问静态同步方法，锁都会加到类对象上。就好比是房子的大门，房子内不论有多少房间，只要有一个人打开大门进入到房子里，其他人就只能等他出来之后再进去，而已经进去的人拥有所有房间的使用权。
场景2
描述：在不同线程中用不同的类实例访问相同静态方法
new Thread(new Runnable() {
@Override
public void run() {
SyncStaticClazz syncStaticClazz = new SyncStaticClazz();
syncStaticClazz.method1();
}
}).start();
new Thread(new Runnable() {
@Override
public void run() {
SyncStaticClazz syncStaticClazz = new SyncStaticClazz();
syncStaticClazz.method1();
}
}).start();
结果：互斥
解析：和场景1相同，静态方法虽然可以被类实例访问，但锁依然是类锁
场景3
描述：同一个对象在不同线程中访问不同的非静态同步方法
SyncClazz syncClazz = new SyncClazz();
new Thread(new Runnable() {
@Override
public void run() {
syncClazz.method1();
}
}).start();
new Thread(new Runnable() {
@Override
public void run() {
syncClazz.method2();
}
}).start();
结果：互斥
解析：非静态方法上加的是对象锁，当对象调用一个非静态的同步方法时，其他的非静态同步方法需要等待被执行。
场景4
描述：不同对象在不同线程中访问同一个非静态方法
new Thread(new Runnable() {
@Override
public void run() {
SyncClazz syncClazz = new SyncClazz();
syncClazz.method1();
}
}).start();
new Thread(new Runnable() {
@Override
public void run() {
SyncClazz syncClazz = new SyncClazz();
syncClazz.method1();
}
}).start();
结果：不互斥
解析：因为通过不同的对象调用的是非静态方法，虽然调用的是同一个方法，但是非静态方法加的锁是对象锁，针对的是对象并不是方法，所以可以并发执行，不会互斥。如果像场景1中的比喻的话，就是两个对象是两套房子，户型相同而已。
场景5
描述：不同对象在不同线程中访问同一个非静态非同步方法，方法内通过synchronized锁定代码块，且锁定对象为类对象
new Thread(new Runnable() {
@Override
public void run() {
SyncClazz syncClazz = new SyncClazz();
syncClazz.method3();
}
}).start();
new Thread(new Runnable() {
@Override
public void run() {
SyncClazz syncClazz = new SyncClazz();
syncClazz.method3();
}
}).start();
结果：互斥
解析：因为方法method3()内的synchronized锁的是SyncClazz.class，也就是锁定的是类对象，所以与场景2相同
场景6
描述：同一个对象在不同线程中访问不同的非静态非同步方法，方法内通过synchronized锁定代码块，且锁定对象为类对象
SyncClazz syncClazz = new SyncClazz();
new Thread(new Runnable() {
@Override
public void run() {
syncClazz.method3();
}
}).start();
new Thread(new Runnable() {
@Override
public void run() {
syncClazz.method5();
}
}).start();
}
结果：互斥
解析：因为方法method3()和method5()内的synchronized锁的是SyncClazz.class，也就是锁定的是类对象，所以与场景2相同
场景7
描述：同一个对象在不同线程中访问不同方法，一个调用静态方法，一个调用非静态方法
SyncStaticClazz syncClazz = new SyncStaticClazz();
new Thread(new Runnable() {
@Override
public void run() {
syncClazz.method1();
}
}).start();
new Thread(new Runnable() {
@Override
public void run() {
syncClazz.method3();
}
}).start();
结果：不互斥
解析：虽然是同一个对象调用，但是两个方法的锁类型不同，静态方法是类锁，非静态方法是对象锁，所以不会互斥
场景8
描述：同一个对象在不同线程中访问不同synchronized代码块方法，一个调用类对象同步，一个调用类实例同步
SyncClazz syncClazz = new SyncClazz();
new Thread(new Runnable() {
@Override
public void run() {
syncClazz.method3();
}
}).start();
new Thread(new Runnable() {
@Override
public void run() {
syncClazz.method4();
}
}).start();
结果：不互斥
解析：与场景7相同
总结
对象锁仅锁当前对象，不同对象之间不会互斥
静态方法上的锁是类锁，非静态方法上的锁是对象锁
所有静态同步方法互斥，无论是通过类调用还是对象调用
静态方法上加synchronized与在非静态方法内加synchronized(Xxx.class)效果一致，都是类锁
