synchronized锁（方法锁, 代码块锁）

synchronized锁可以解决线程安全问题，但是相应的，只要是锁，就会带来性能开销，所以尽可能减小锁的范围尤为重要。

synchronized锁无非修饰普通方法，修饰静态方法，修饰代码块，我认为无非就两种（对象锁、类锁），只不过是锁的使用对象不同而已，实际上synchronized锁的作用范围，取决于使用对象的生命周期。接下来简单介绍几种不同影响范围的锁。

synchronized修饰普通方法（对象锁）

普通方法作用范围是对象实例，不可跨对象，所以多个线程不同对象实例访问此方法，互不影响，无法产生互斥。

public class SynchronizedDemo {
    // 修饰普通方法（实例方法）
    public synchronized void instanceMethod() {
        // TODO 业务逻辑
    }

    public static void main(String[] args) {
        SynchronizedDemo obj1 = new SynchronizedDemo();
        SynchronizedDemo obj2 = new SynchronizedDemo();
        new Thread(() ->{
            obj1.instanceMethod(); //多线程访问加锁普通实例方法，互不影响
        }).start();
        new Thread(() ->{
            obj2.instanceMethod();
        }).start();
    }
}

synchronized修饰静态方法（类锁）

静态方法是通过类访问，是类级别的跨对象的，所以锁的范围是针对类，多个线程访问互斥。

public class SynchronizedDemo {
    // 修饰静态方法（类方法）
    public synchronized static void staticMethod() {
        // TODO 业务逻辑
    }

    public static void main(String[] args) {
        new Thread(() ->{
            SynchronizedDemo.staticMethod(); //多线程访问加锁静态方法，互斥
        }).start();
        new Thread(() ->{
            SynchronizedDemo.staticMethod();
        }).start();
    }
}

synchronized修饰代码块

括号里是对象（类似对象锁）

作用范围是对象实例，不可跨对象，所以多个线程不同对象实例访问此方法，互不影响，无法产生互斥。

public class SynchronizedDemo {
    // 代码块锁(对象实例)：锁的应用对象是当前对象实例，可以称之为对象锁
    public void method1() {
        synchronized (this) {
            // TODO 业务逻辑
        }
    }

    public static void main(String[] args) {
        SynchronizedDemo obj1 = new SynchronizedDemo();
        SynchronizedDemo obj2 = new SynchronizedDemo();
        new Thread(() ->{
            obj1.method1(); //代码块锁，后面是对象，多线程访问互不影响
        }).start();
        new Thread(() ->{
            obj2.method1();
        }).start();
    }
}

括号里是类（类似类锁）

虽然是通过对象访问的此方法，但是加锁的代码块是类级别的跨对象的，所以锁的范围是针对类，多个线程访问互斥。

public class SynchronizedDemo {
    // 代码块锁(类)：锁的应用对象是User类，可以称之为类锁
    public void method2() {
        synchronized (User.class) {
            // TODO 业务逻辑
        }
    }

    public static void main(String[] args) {
        SynchronizedDemo obj1 = new SynchronizedDemo();
        SynchronizedDemo obj2 = new SynchronizedDemo();
        new Thread(() ->{
            obj1.method2(); //代码块锁，后面是类，多线程访问互斥
        }).start();
        new Thread(() ->{
            obj2.method2();
        }).start();
}

MarkWord对象头

对象头中会保存当前对象的锁标记，如果是lock的是对象实例，那么两个对象各自会保存锁标记，不是同一个锁标记，所以无法形成互斥。

查看对象头信息工具

加入pom依赖

<dependency>
    <groupId>org.openjdk.jol</groupId>
    <artifactId>jol-core</artifactId>
    <version>0.9</version>
</dependency>

使用方法

public class ClassLayoutDemo {
    public static void main(String[] args) {
        ClassLayoutDemo demo = new ClassLayoutDemo();
        // 打印对象头内存布局
        System.out.println(ClassLayout.parseInstance(demo).toPrintable());
    }
}

打印结果

前八个字节对应的是对象头信息，接下面4个字节是类元指针数据，最后4个字节是对齐填充。

synchronized锁的优化升级

JDK1.6以前只有无锁和重量级锁两种，但是重量级锁太沉重，太消耗CPU性能；所以JDK1.6之后引入了偏向锁和轻量级锁，对锁进行了优化升级，这是一个无锁化的实现，减轻线程阻塞和唤醒带来的CPU消耗。

无锁：没有加锁

偏向锁：没有其他线程竞争的情况下，线程A抢占锁，这个时候会偏向于线程A。偏向锁默认延迟开启。

轻量级锁：如果线程A抢占到锁，此时线程B来竞争，抢占锁失败，那么此时通过轻量级锁来避免线程被阻塞，一直在循环尝试获取锁，可以避免线程阻塞唤醒导致的用户态和内核态之间的切换，可以减轻CPU压力；如果循环一定次数后依然没有抢占到锁，那么才会升级为重量级锁。

自旋锁：自旋锁是轻量级锁的一种实现，通过for循环来自我循环去尝试获取锁，通过CAS机制去判断锁的标识状态。

重量级锁：有锁，线程会阻塞，直到抢占到锁被唤醒，会涉及到用户态和内核态之间的切换。

Lock锁与synchronized锁的区别

1) Lock锁需要手工释放，而synchronized锁会自动释放；
2) Lock锁有很多实现，有独占锁互斥锁重入锁，还有共享锁，而synchronized是互斥锁重入锁；
3) Lock是个接口，有很多锁的实现类，而synchronized只是个关键字；
4) Lock只能作用在代码块上，而synchronized既可以修饰代码块还是修饰方法；
5) Lock支持公平和不公平抢占，而synchronized是不公平锁；
6) Lock锁支持阻塞和不阻塞加锁，而synchronized锁支持阻塞加锁；
7) Lock可以设置超时机制，而synchronized不能设置超时；
8) Lock可以中断，而synchronized不可中断；
9) Lock底层原理是AQS，而synchronized是通过monitor对象监听器；