浅谈Java内部锁synchronized

了解Java的朋友们都知道jdk提供的用于保证线程安全的锁有两类：内部锁synchronized和显示锁Lock，本文对内部锁synchronized做一些简要的分析汇总。

内部锁的使用范式

1.同步实例方法

    int count;
    synchronized void syncA() {
        count++;
    }
1
2
3
4

等效于：

    int count;
    void syncA() {
        synchronized (this) {
            count++;
        }
    }
1
2
3
4
5
6

上述两个等效的同步实例方法都是同步在this当前对象。

2.同步静态方法(类方法)

public class Foo {
    static int classCount;
    static synchronized void syncB() {
        classCount++;
    }
}
1
2
3
4
5
6

等效于：

public class Foo {
    static int classCount;
    static void syncB() {
        synchronized (Foo.class) {
            classCount++;
        }
    }

}
1
2
3
4
5
6
7
8
9

上述两个同步的类方法都是同步在类对象Foo.class上面，类对象也是对象。

实际中我们也会经常这样使用：

    private final Object lock = new Object();
    
    int count;
    void syncA() {
        synchronized (lock) {
            count++;
        }
    }
1
2
3
4
5
6
7
8

作为锁对象（锁句柄）使用的lock要声明为不可变对象，因为对多个线程来说，只有同步在相同的锁(同一把锁)上才有意义，才能保证共享数据的安全。

内部锁的特点

1. 是互斥的，
2. 是可重入的
3. 是非公平的

互斥是指锁一次只能被一个线程持有：

可重入是指一个线程持有锁A，那么它还可以继续执行被锁A保护的其它方法(代码)：

public class Foo2 {

    private static final Object lock = new Object();

    static void syncA() {
        synchronized (lock) {
            System.out.println("syncA: do something");
            syncB();
        }
    }

    static void syncB() {
        synchronized (lock) {
            System.out.println("syncB: do something");
        }
    }

    public static void main(String[] args) {
        syncA();
    }

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

执行main方法可看到如下输出;

内部锁的可重入是由JVM实现的，在对象头中会记录重入的次数，重入时只需加1即可，无需再次走申请锁的耗费资源的流程。

非公平是指多个线程在抢占锁时JVM并不会保证线程先来后到的顺序，非公平性可以提升吞吐量，因为少了维护线程顺序的开销.

内部锁的简要原理

内部锁synchronized在JVM中的实现被称为monitor，即监视器，所以也叫监视器锁。对应的字节码指令为：
monitorenter：分配锁
monitorexit：释放锁
synchronized对应的字节码指令monitorenter和monitorexit总是成对出现（申请到锁就能释放锁），所以你在代码中使用synchronized无需手动释放锁，释放锁由JVM保证。如下简单的代码

public class Foo {

    private static final Object lock = new Object();
    static int count;

    static void syncA() {
        synchronized (lock) {
            count++;
        }
    }

    public static void main(String[] args) {
        syncA();
        System.out.println(count);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

方法syncA的字节码指令：

官方对monitor的描述：Java中每一个对象都有monitor

这也就回答了为什么Object类中会有wait/notify/notifyAll等方法

内部锁的优化和细分类型

内部锁在代码层面对应的是synchronized关键字，从Java7开始JVM已经开始对synchronized进行优化，并不会像早期实现中直接进入重量级锁模式。JVM对内部锁的优化有：

1. 支持锁消除，即无锁（JIT编译器利用逃逸分析和内联优化进行运行时的优化处理）
2. 支持偏向锁，对象头中有记录当前锁是否是偏向锁及偏向线程的id
3. 支持锁自适应，抢锁的线程可以自旋也可以直接升级为重量级锁
   
   OK，回聊