锁
Synchronized
1、可用范围
- 类
public void demo() {
synchronized (synchronizedDemo.class) {
}
}
public synchronized static void demo() {
}
- 方法
public synchronized void demo() {
}
public void demo() {
synchronized (this) {
}
}
2、Markwork锁信息存储
1、 为什么每个 java 对象都可以作为锁对象
> Java 中的对象，都是派生自 Object 类，每个 Java Object 在 JVM 源码中都有一个 native 对象与之对应
2、 synchronized (lock) ，关于锁的操作，都是对 lock 这个对象的生命周期进行操作
3、 Mark word，记录了对象和锁的相关信息
enum { age_bits = 4, // 分带年龄
lock_bits = 2, // 锁标记位
biased_lock_bits = 1, // 偏向锁标记，标记是否为偏向锁
max_hash_bits = BitsPerWord - age_bits - lock_bits - biased_lock_bits,
hash_bits = max_hash_bits > 31 ? 31 : max_hash_bits,
cms_bits = LP64_ONLY(1) NOT_LP64(0),
epoch_bits = 2 // 偏向锁的时间戳
};
4、锁的升级
经过 3. 分析，发现在内核态和用户态之间来回切换，对性能有所影响，所以在 JDK 1.6 之后进行了更新优化
4.1 锁的升级步骤
偏向锁 -> 轻量级锁 -> 重量级锁
其中，偏向锁和轻量级锁，可以说是一种无锁状态，其中轻量级锁也可以说是自旋锁
4.2 偏向锁
4.2.1 大体理论
偏向锁的大体理论就是，当一个线程访问同步代码的时候，会在对象头里存储自己当前的线程ID，当要获取锁的时候和锁对象的 Mark word 信息进行对比，若一致则直接进入，执行同步，当后续这个线程在进入的时候不会进行加锁和解锁操作，若对比时不一致，代表此时有线程和它进行竞争，这时会对已经获取到偏向锁的线程进行偏向锁的撤销，并将其升级为轻量级锁
偏向锁一般只适用于一个线程访问的情况
4.2.1 使用前提
- biased_lock_bits 偏向锁标记为 1
- ThreadId 为空
表示为可偏向状态，信息存储在 Mark word 中
4.2.3 执行流程
- 获取对象的 Mark word 信息，确定当前为可偏向状态
-
如果是可偏向状态，通过 CAS 操作，将线程ID等信息，写入到锁对象的 Mark word 中
- 如果 CAS 写入成功，则当前锁对象的 Mark word 存储的 ThreadID 就是当前线程的 ThreaId ，可以执行同步代码块中的内容
- 如果 CAS 写入失败，则表示当前锁对象已经有线程获取到了，也就是现在存在了锁竞争的情况，这时会将先前已经获取锁的对象的偏向锁进行撤销，并将其升级为轻量级锁（这些操作会等待到一个全局安全点，也就是没有执行字节码的时候进行操作）
- 如果是已偏向状态，则直接对比 ThreadId 信息即可
- 相等，直接进行执行操作
- 不相等，则表明竞争，和上述相同的操作
4.2.4 设置关闭
-XX:-UseBiasedLocking=false 关闭
4.3 轻量级锁
4.3.1 大体理论
在偏向锁阶段出现竞争的话，会将锁信息撤销，并将 Mark Work 中的 ThreadID 信息置为空，将锁升级为轻量级锁，轻量级锁也可以说是自旋锁，它适用于同步代码块中的代码执行速度很快的情况下，在ThreadA已经1获得对象锁开始执行同步代码块的时候，ThreadB获取锁失败，开始进行自旋尝试获得锁，直到获取成功，但这样一直自旋也会带来性能上的开销，所以轻量级锁分为自旋锁和自适应自旋锁
- 自旋锁：一直自旋，直到获取成功
for(;;){
// TODO 获得锁
}
- 自适应自旋锁：由系统自己判断，若之前对这个锁对象获取成功率都比较高，则认为这一次会获取成功，会继续进行自旋，若之前成功率都很低而且需要很长时间才可以获取到，系统会降低自旋的次数，甚至不进行自旋，直接将线程挂起阻塞
4.3.2 执行流程
- 首先会先在栈中开辟出来一块空间，存储Lock 的相关信息 （Lock Record）
- 将Mark Word 中的信息，复制到 Lock Record 当中
- 将设置好的 Lock Record 赋值到 Mark Word ，并将Lock Record 的 owner 设置为当前锁对象
- 成功：表示线程已经获取到锁，并将 Mark word 的锁标记设置为 00
- 失败：若更新失败会首先检查 Mark Word 是否指向当前线程的栈帧，若指向则继续执行，若不是，则表明存在竞争，会膨胀为重量级锁，锁标记为10
- 执行完毕后，要通过 CAS 将线程栈帧中的 Lock Record 信息，替换回 Mark Word 中，若失败，表示有线程在竞争锁，锁升级为膨胀锁
5、重量级锁
// 获取到 ObjectMonitor 对象，通过该对象进行加锁
ObjectMonitor* monitor() const {
assert(has_monitor(), "check");
// Use xor instead of &~ to provide one extra tag-bit check.
return (ObjectMonitor*) (value() ^ monitor_value);
}
我们通过 javap -v 类名.class 可以看到
monitorenter 指令尝试获取到对象锁
monitorexit 指令对锁进行释放
第二个 monitorexit 在抛出异常时，执行
基本流程就是，每一个 java 对象都会与一个 monitor 监视器对象进行关联，线程A 通过执行 monitorenter 指令，尝试获取 ObjectMonitor 监视器对象，若获取成功，则执行同步代码块，执行完毕后执行 monitorexit 指令，进行 监视器对象的释放，若没有获得 ObjectMonitor 对象，则会将其添加到一个同步队列中，等待之前的线程执行完毕后，释放ObjectMonitro 对象，同时对同步队列进行唤醒，后者再次尝试执行 monitorenter 执行，对监视器对象进行获取。
而加锁解锁的操作，是基于底层操作系统去实现的，像 Linux 是 mutexLock 一个互斥锁，线程在被堵塞后就会进入 内核态等待系统调度，这个就会导致在系统态和内核态之间来回切换，影响效率。
6、wait / notify 线程通信
- wait：表示放弃当前线程持有的 CPU 资源，并释放锁权限，进入等待状态
- notify：对进行等待状态的线程进行唤醒，唤醒之后立即获得锁权限
- notify / notifyAll：前者唤醒一个，立马获得锁权限，后者唤醒全部，竞争锁资源
需要注意的是：三个方法都必须在 synchronized 同步关键字锁限定的作用域中执行 ，否则会抛出java.lang.IllegalMonitorStateException
7、join 操作
- join 操作可以用来实现线程的顺序执行 ThreadA -> ThreadB -> ThreadC 可以通过 ThreadA.join(),ThreadB().join() 来实现
- join 的底层也是调用的 wait 方法
public final synchronized void join(long millis)
throws InterruptedException {
long base = System.currentTimeMillis();
long now = 0;
if (millis < 0) {
throw new IllegalArgumentException("timeout value is negative");
}
if (millis == 0) {
while (isAlive()) { // 如果 线程还存活，调用 wait 方法
wait(0);
}
} else {
while (isAlive()) {
long delay = millis - now;
if (delay <= 0) {
break;
}
wait(delay);
now = System.currentTimeMillis() - base;
}
}
}
当线程生命周期结束的时候
static void ensure_join(JavaThread* thread) {
// We do not need to grap the Threads_lock, since we are operating on ourself.
Handle threadObj(thread, thread->threadObj());
assert(threadObj.not_null(), "java thread object must exist");
ObjectLocker lock(threadObj, thread);
。。。 。。。
java_lang_Thread::set_thread(threadObj(), NULL);
// 会调用 notify_all 进行唤醒
lock.notify_all(thread);
// Ignore pending exception (ThreadDeath), since we are exiting anyway
thread->clear_pending_exception();
}