了解Java的朋友们都知道jdk提供的用于保证线程安全的锁有两类：内部锁synchronized和显示锁Lock，本文对内部锁synchronized做一些简要的分析汇总。
内部锁的使用范式
1.同步实例方法
int count;
synchronized void syncA() {
count++;
}
等效于：
int count;
void syncA() {
synchronized (this) {
count++;
}
}
上述两个等效的同步实例方法都是同步在this当前对象。
2.同步静态方法(类方法)
public class Foo {
static int classCount;
static synchronized void syncB() {
classCount++;
}
}
等效于：
public class Foo {
static int classCount;
static void syncB() {
synchronized (Foo.class) {
classCount++;
}
}
}
上述两个同步的类方法都是同步在类对象Foo.class上面，类对象也是对象。
实际中我们也会经常这样使用：
private final Object lock = new Object();
int count;
void syncA() {
synchronized (lock) {
count++;
}
}
作为锁对象（锁句柄）使用的lock最好要声明为不可变对象，因为对多个线程来说，只有同步在相同的锁(同一把锁)上才有意义，才能保证共享数据的安全。
内部锁的特点
- 是互斥的，
- 是可重入的
- 是非公平的
可重入是指一个线程持有锁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();
}
}
内部锁的可重入是由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);
}
}
这也就回答了为什么Object类中会有wait/notify/notifyAll等方法
内部锁的优化和细分类型
内部锁在代码层面对应的是synchronized关键字，从Java7开始JVM已经开始对synchronized进行优化，并不会像早期实现中直接进入重量级锁模式。JVM对内部锁的优化有：
- 支持锁消除，即无锁(JIT编译器利用逃逸分析和内联优化进行运行时的优化处理）
- 支持偏向锁, 对象头中有记录当前锁是否是偏向锁及偏向线程的id
-
支持锁自适应，抢锁的线程可以自旋也可以直接升级为重量级锁f17f1fb7c4519f53197eb15604a3f58.png
OK，回聊
