目录
一. synchronized 的特性
互斥性
synchronized 会起到互斥作用,某个线程执行到某个对象的synchronized中时,其他线程如果也执行到同一个对象synchronized就会阻塞等待
-
进入synchronized修饰的代码块相当于加锁
-
退出synchronized修饰的代码块相当于解锁
-
这个就类似于厕所,加上synchronized就会厕所设为有人状态,退出的时候就会设为无人状态
一个人进去厕所之后设为了有人,然后其他人想进入厕所的话只能阻塞等待,等到这个状态设为无人时(就是解锁之后),操作系统就可以唤醒一个新的线程,再来获取这个锁,被唤醒的线程是随机的,不是先来后到的规则
所以synchronized 底层是使用操作系统的mutex lock 实现的
刷新内存
synchronized的工作过程
-
获得互斥锁
-
从内存拷贝变量的最新副本到工作的内存
-
执行代码
-
将更改后的共享变量的值刷新到主内存
-
释放互斥锁
所以synchronized也能保证内存可见性
可重入
synchronized同步代码块对同一条线程来说是可重入的,不会出现把自己锁死的问题
死锁:
一个线程没有释放锁,然后另一个线程尝试加锁,这样就形成了阻塞等待.(然后就死锁了,也就是不可重入)
lock();
lock(); //这次再加锁的时候,锁已经被占用了,形成了阻塞等待
java中的synchronized是可重入锁,因此没有上述问题
代码示例
static class Counter {
public int count = 0;
synchronized void increase() {
count++;
}
//连续加锁没有问题,是可重入锁
synchronized void increase2() {
increase();
}
}
在可重入锁的内部,包含了"线程持有者" 和 " 计数器" 两个信息
-
如果某个线程加锁了时,发现这个锁已经被占用了,但是恰好正是自己,那么任然可以继续获取到锁,并让计数器自增
-
解锁的时候计数器递减为0时,就真正的释放锁了(才能别的线程获取到)
二. synchronized使用示例
synchronized 本质上要修改指定对象的"对象头",从使用的角度来看,synchronized也要搭配一个具体的对象来使用.
synchronized 修饰普通方法时,锁的是当前对象的方法,等价于 synchronized (this)
synchronized 修饰静态方法时,锁的是所有对象的方法,等价于 synchronized (Xxx.class)
-
直接修饰普通方法:锁的是Main 对象的方法
public class Main {
public synchronized void method() {
}
}
-
修饰静态方法:锁的是Main类对象(整个类)
public class Main {
public static synchronized void method() {
}
}
-
修饰代码块:明确指定那个对象
锁当前对象
public class Main {
public synchronized void method() {
synchronized(this) {
}
}
}
锁类对象
public class Main {
public synchronized void method() {
synchronized(Main.class) {
}
}
}
两个线程获取同一把锁会产生阻塞等待
总结
-
开始时是乐观锁, 如果锁冲突频繁, 就转换为悲观锁.
-
开始是轻量级锁实现, 如果锁被持有的时间较长, 就转换成重量级锁.
-
实现轻量级锁的时候大概率用到的自旋锁策略
-
是一种不公平锁
-
是一种可重入锁
-
不是读写锁
三.Synchronized原理
加锁的工作过程
jvm将Synchronized锁分为,无锁,偏向锁,轻量级锁,重量级锁状态.会根据情况,进行依次升级
偏向锁
第一个尝试加锁的线程, 优先进入偏向锁状态.
偏向锁不是真的 "加锁", 只是给对象头中做一个 "偏向锁的标记", 记录这个锁属于哪个线程. 如果后续没有其他线程来竞争该锁, 那么就不用进行其他同步操作了(避免了加锁解锁的开销) 如果后续有其他线程来竞争该锁(刚才已经在锁对象中记录了当前锁属于哪个线程了, 很容易识别 当前申请锁的线程是不是之前记录的线程), 那就取消原来的偏向锁状态, 进入一般的轻量级锁状态. 偏向锁本质上相当于 "延迟加锁" . 能不加锁就不加锁, 尽量来避免不必要的加锁开销. 但是该做的标记还是得做的, 否则无法区分何时需要真正加锁.
轻量级锁
随着其他线程进入竞争, 偏向锁状态被消除, 进入轻量级锁状态(自适应的自旋锁). 此处的轻量级锁就是通过 CAS 来实现. 比特就业课 通过 CAS 检查并更新一块内存 (比如 null => 该线程引用) 如果更新成功, 则认为加锁成功 如果更新失败, 则认为锁被占用, 继续自旋式的等待(并不放弃 CPU). 自旋操作是一直让 CPU 空转, 比较浪费 CPU 资源. 因此此处的自旋不会一直持续进行, 而是达到一定的时间/重试次数, 就不再自旋了. 也就是所谓的 "自适应"
重量级锁
如果竞争进一步激烈, 自旋不能快速获取到锁状态, 就会膨胀为重量级锁 此处的重量级锁就是指用到内核提供的 mutex . 执行加锁操作, 先进入内核态. 在内核态判定当前锁是否已经被占用 如果该锁没有占用, 则加锁成功, 并切换回用户态. 如果该锁被占用, 则加锁失败. 此时线程进入锁的等待队列, 挂起. 等待被操作系统唤醒. 经历了一系列的沧海桑田, 这个锁被其他线程释放了, 操作系统也想起了这个挂起的线程, 于是唤醒 这个线程, 尝试重新获取锁
其他的优化操作
锁消除
编译器 + JVM判断锁是否可以消除,如果可以,就直接消除
什么是"锁消除"
stringBuffer sb = new StringBuffer(); sb.append("a"); sb.append("b"); sb.append("c"); sb.append("d"); //此时每个 append 的调用都会涉及加锁和解锁. 但如果只是在单线程中执行这个代码, 那么这些加 //锁解锁操作是没有必要的, 白白浪费了一些资源开销.
锁粗化
一段逻辑中如果多次加锁和解锁,编译器 +JVM会自动进行锁的粗化
锁的粒度:粗和细
实际开发过程中, 使用细粒度锁, 是期望释放锁的时候其他线程能使用锁. 但是实际上可能并没有其他线程来抢占这个锁. 这种情况 JVM 就会自动把锁粗化, 避免频繁申请释 放锁
粗和细
方式一: 打电话, 交代任务1, 挂电话. 打电话, 交代任务2, 挂电话. 打电话, 交代任务3, 挂电话.
方式二: 打电话, 交代任务1, 任务2, 任务3, 挂电话. 显然, 方式二是更高效的方案(粗化)
总结
简单来说,synchronized的原理就是通过内部锁实现对共享资源的互斥访问,保证多线程环境下的数据安全性
总之,synchronized是Java中重要的同步机制,能够有效地保证多线程并发访问共享资源的正确性和可靠性。虽然它存在一些缺点,但在实际开发中仍然被广泛应用,对于Java程序员来说,掌握synchronized的使用方法和原理是非常重要的。