synchronized: 又叫监视器锁 monitor lock
(保证原子性)
synchronized 会起到互斥效果, 某个线程执行到某个对象的 synchronized 中时, 其他线程如果也执行到同一个对象 synchronized 就会阻塞等待.
synchronized 用的锁是存在Java对象头里的。
加锁就是在这个对象头中设置一个标志位。
可以粗略理解成, 每个对象在内存中存储的时候, 都存有一块内存表示当前的 “锁定” 状态(类似于厕所的 “有人/无人”).
如果当前是 “无人” 状态, 那么就可以使用, 使用时需要设为 “有人” 状态.
如果当前是 “有人” 状态, 那么其他人无法使用, 只能排队.
阻塞等待:
针对每一把锁, 操作系统内部都维护了一个等待队列. 当这个锁被某个线程占有的时候, 其他线程尝
试进行加锁, 就加不上了, 就会阻塞等待, 一直等到之前的线程解锁之后, 由操作系统唤醒这些正在等待的线程中的一个线程来获取到这个锁.
注意:
synchronized的底层是使用操作系统的mutex lock实现的.
(保证内存可见性)
synchronized 的工作过程:
所以 synchronized 也能保证内存可见性.
class ThreadDemo {
static class Counter {
public int flag = 0;
}
public static void main(String[] args) {
Counter counter = new Counter();
Thread t1 = new Thread(() -> {
while (true) {
synchronized (counter) {
if (counter.flag != 0) {
break;
}
}
// do nothing
}
System.out.println("循环结束!");
});
Thread t2 = new Thread(() -> {
Scanner scanner = new Scanner(System.in);
System.out.println("输入一个整数:");
counter.flag = scanner.nextInt();
});
t1.start();
t2.start();
}
}
加上 synchronized,输入一个非 0 整数, t1 线程立马就能感知到,退出循环,
但是如果不加上 synchronized, 输入一个非 0 整数, t1 线程是不能感知到的,t1 还是从寄存器中读取 flag 的初始值 0, 而不是从内存中读取最新的值。
synchronized 同步块对同一条线程来说是可重入的,不会出现自己把自己锁死的问题;
把自己锁死: 一个线程没有释放锁, 然后又尝试再次对同一把锁加锁.
Object locker = new Object();
synchronized (locker) {
System.out.println("第一次上锁");
synchronized (locker) {
System.out.println("第二次上锁");
}
}
按照之前对于锁的设定, 第一次加锁的时候,加锁成功。
第二次加锁的时候, 因为锁已经被占用了,如果让成功加锁,就说明是可重入锁,否则就会阻塞等待, 直到外层代码执行完,锁才被释放, 但是外层代码想要执行完,必须将内层的代码执行完,而内层代码在阻塞,等外层释放锁,这时候就会 死锁,就说明是不可重入锁。
类似于疫情期间的一个例子:
员工A 所在公司发明出了健康码,有一天,健康码崩了,A 需要去公司修复,但是 A 进不去公司,
因为保安说了,你得出示健康码才能进入公司,但是 A 需要先进入公司将健康码修复才能出示。
就是上述情况,如果说发生这种情况会死锁的话,就说明是不可重入锁,否则没发生死锁的话就是可重入锁。
因为 synchronized 是可重入锁,所以上述代码能正常输出:
在可重入锁的内部, 包含了 “线程持有者” 和 “计数器” 两个信息.
可重入锁的意义:
降低程序员的负担,但也带来代价,程序中会有更高的开销,需要维护锁被哪个线程占用,并且加减计数器,降低了运行效率。
synchronized 本质上要修改指定对象的 “对象头”. 从使用角度来看, synchronized 也势必要搭配一个具体的对象来使用.
对类的实例对象加锁(锁加在了 this 上)
class SynchronizedDemo {
public synchronized void methond() {
}
public static void main(String[] args) {
SynchronizedDemo instance = new SynchronizedDemo();
instance.methond();
}
}
针对 SynchronizedDemo 类的实例对象 instance 加锁
锁竞争的例子:
class ThreadDemo {
static class Counter {
public int count = 0;
synchronized void increase() {
count++;
}
}
public static void main(String[] args) throws InterruptedException {
final Counter counter = new Counter();
Thread t1 = new Thread(() -> {
for (int i = 0; i < 50000; i++) {
counter.increase();
}
});
Thread t2 = new Thread(() -> {
for (int i = 0; i < 50000; i++) {
counter.increase();
}
});
t1.start();
t2.start();
t1.join();
t2.join();
System.out.println(counter.count);
}
}
针对类对象加锁
public class SynchronizedDemo {
public synchronized static void method() {
}
}
这个等价于:
public class SynchronizedDemo {
public static void method() {
synchronized (SynchronizedDemo.class) {
}
}
}
都是针对:SynchronizedDemo 类对象加锁,
类对象: 就是 .class 文件被加载到 JVM 中的模样。
锁竞争的例子:
class SynchronizedStaticMethodExample {
public static synchronized void staticMethod1() {
// 静态同步方法1逻辑
while (true) {
System.out.println("staticMethod1");
}
}
public static synchronized void staticMethod2() {
// 静态同步方法2逻辑
while (true) {
System.out.println("staticMethod2");
}
}
public static void main(String[] args) {
Thread thread1 = new Thread(() -> {
staticMethod1();
});
Thread thread2 = new Thread(() -> {
staticMethod2();
});
thread1.start();
thread2.start();
}
}
需要明确指定锁哪个对象.
public class SynchronizedDemo {
public void method() {
synchronized (this) {
}
}
}
public class SynchronizedDemo {
public void method() {
synchronized (SynchronizedDemo.class) {
}
}
}
class SynchronizedDemo {
public void method() {
Object locker = new Object();
synchronized (locker) {
}
}
}
锁竞争的例子:
class SynchronizedBlockExample {
private Object lock = new Object();
public void method1() {
synchronized (lock) {
// 同步块1的逻辑
while (true) {
System.out.println("method1");
}
}
}
public void method2() {
synchronized (lock) {
// 同步块2的逻辑
while (true) {
System.out.println("method2");
}
}
}
public static void main(String[] args) {
SynchronizedBlockExample example = new SynchronizedBlockExample();
Thread thread1 = new Thread(() -> {
example.method1();
});
Thread thread2 = new Thread(() -> {
example.method2();
});
thread1.start();
thread2.start();
}
}
注意:
两个线程竞争同一把锁, 才会产生阻塞等待.
两个线程分别尝试获取两把不同的锁, 不会产生竞争.
不能无脑使用 synchronized :
synchronized 的使用是要付出代价的,一旦使用 synchronized 就很容易造成线程阻塞,一旦线程阻塞(释放 CPU),下次再被调度到 CPU 上执行的时间就不可控了,自然就会拖慢任务的执行
一旦使用了 synchronized,基本就和 “高性能” 无缘了。
Java 标准库中很多都是线程不安全的. 这些类可能会涉及到多线程修改共享数据, 又没有任何加锁措施.
还有一些是线程安全的. 使用了一些锁机制来控制.
还有的虽然没有加锁, 但是不涉及 “修改”, 仍然是线程安全的
不推荐使用 Vector 和 HashTable 就是因为它们无脑使用 synchronized,性能低。
好啦! 以上就是对 synchronized 的用法详解,希望能帮到你 !
评论区欢迎指正 !