synchronized修饰普通方法，锁的是当前对象
初始化一个对象时，会自动生成一个与该对象对应的对象锁，被synchronized 修饰的方法就得依靠对象锁工作。当多线程同时访问某个被synchronized修饰的方法时，一旦某个进程抢得对象锁之后，其他的进程只有排队对待。
同一个对象在两个线程中分别访问该对象的两个同步方法会产生互斥
因为锁针对的是对象，当对象调用一个synchronized方法时，其他同步方法需要等待其执行结束并释放锁后才能执行。
//测试普通的同步方法
public synchronized void test1() {
for (int i = 0; i < 5; i++){
System.out.println("现在在test1内部,休息1秒");
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
System.out.println("从test1出来，释放锁");
}
public synchronized void test2() {
for (int i = 0; i < 5; i++){
System.out.println("现在在test2内部，休息1秒");
try {
Thread.sleep(5000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
System.out.println("从test2出来，释放锁");
}
}
Main方法建立测试类
NormalSychronizedDemo demo = new NormalSychronizedDemo();
new Thread(new Runnable() {
@Override
public void run() {
demo.test1();
}
},"thread1").start();
new Thread(new Runnable() {
@Override
public void run() {
demo.test2();
}
},"thread2").start();
现在在test1内部,休息1秒
现在在test1内部,休息1秒
现在在test1内部,休息1秒
现在在test1内部,休息1秒
现在在test1内部,休息1秒
从test1出来，释放锁
现在在test2内部，休息1秒
现在在test2内部，休息1秒
现在在test2内部，休息1秒
现在在test2内部，休息1秒
现在在test2内部，休息1秒
从test2出来，释放锁
从打印结果可知当线程1进入时，线程2必须等待线程1释放锁才可以进入。
当新建两个不同的对象去调用test1方法时，调用同一个同步方法，不会产生互斥。
因为是两个对象，锁针对的是对象，并不是方法，所以可以并发执行，不会互斥。形象的来说就是因为我们每个线程在调用方法的时候都是new 一个对象，那么就会出现两个空间，两把钥匙，
NormalSychronizedDemo demo = new NormalSychronizedDemo();
NormalSychronizedDemo demo1 = new NormalSychronizedDemo();
new Thread(new Runnable() {
@Override
public void run() {
demo.test1();
}
},"thread1").start();
new Thread(new Runnable() {
@Override
public void run() {
demo1.test1();
}
},"thread2").start();
synchronized修饰静态方法，锁的是当前类对象，俗称“类锁”。
一个对象直接在两个线程中调用两个不同的同步方法会互斥
两个个对象直接在两个线程中调用同一个同步方法会互斥
因为对静态对象加锁实际上对类（.class）加锁，类对象只有一个，可以理解为任何时候都只有一个空间，里面有N个房间，一把锁，因此房间（同步方法）之间一定是互斥的。
class StaticNormalSychronizedDemo{
//测试静态的同步方法
public static synchronized void test1() {
for (int i = 0; i < 5; i++){
System.out.println("现在在test1内部,休息1秒");
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
System.out.println("从test1出来，释放锁");
}
public static synchronized void test2() {
for (int i = 0; i < 5; i++){
System.out.println("现在在test2内部，休息1秒");
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
System.out.println("从test2出来，释放锁");
}
}
测试代码和上面一样
一个对象在两个线程中分别调用一个静态同步方法和一个非静态同步方法不会互斥
因为虽然是一个对象调用，但是两个方法的锁类型不同，调用的静态方法实际上是类对象在调用，即这两个方法产生的并不是同一个对象锁，因此不会互斥，会并发执行。
