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

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

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

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

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

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

查看对象头信息工具

加入pom依赖

    org.openjdk.jol
    jol-core
    0.9

使用方法

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

打印结果

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

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

无锁：没有加锁

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

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

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

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