Synchronized 用法详解

一. synchronized 的特性
- 1. 互斥
- 2. 刷新内存
- 3. 可重入
二. synchronized 的使用
- 1. 直接修饰普通方法
- 2. 修饰静态方法
- 3. 修饰代码块
三. Java 标准库中的线程安全类

synchronized: 又叫监视器锁 monitor lock

一. synchronized 的特性

1. 互斥

(保证原子性)
synchronized 会起到互斥效果, 某个线程执行到某个对象的 synchronized 中时, 其他线程如果也执行到同一个对象 synchronized 就会阻塞等待.

进入 synchronized 修饰的代码块, 相当于加锁
退出 synchronized 修饰的代码块, 相当于解锁

在这里插入图片描述

synchronized 用的锁是存在Java对象头里的。
加锁就是在这个对象头中设置一个标志位。
在这里插入图片描述

可以粗略理解成, 每个对象在内存中存储的时候, 都存有一块内存表示当前的 “锁定” 状态(类似于厕所的 “有人/无人”).
如果当前是 “无人” 状态, 那么就可以使用, 使用时需要设为 “有人” 状态.
如果当前是 “有人” 状态, 那么其他人无法使用, 只能排队.

阻塞等待:
针对每一把锁, 操作系统内部都维护了一个等待队列. 当这个锁被某个线程占有的时候, 其他线程尝
试进行加锁, 就加不上了, 就会阻塞等待, 一直等到之前的线程解锁之后, 由操作系统唤醒这些正在等待的线程中的一个线程来获取到这个锁.

注意：

上一个线程解锁之后, 下一个线程并不是立即就能获取到锁. 而是要靠操作系统来 “唤醒”. 这也就是操作系统线程调度的一部分工作.
假设有 A B C 三个线程, 线程 A 先获取到锁, 然后 B 尝试获取锁, 然后 C 再尝试获取锁, 此时 B 和 C 都在阻塞队列中排队等待. 但是当 A 释放锁之后, 虽然 B 比 C 先来的, 但是 B 不一定就能获取到锁, 而是和 C 重新竞争, 并不遵守先来后到的规则.

synchronized的底层是使用操作系统的mutex lock实现的.

2. 刷新内存

（保证内存可见性）
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，而不是从内存中读取最新的值。

3. 可重入

synchronized 同步块对同一条线程来说是可重入的，不会出现自己把自己锁死的问题；

把自己锁死: 一个线程没有释放锁, 然后又尝试再次对同一把锁加锁.

        Object locker = new Object();
        synchronized (locker) {
            System.out.println("第一次上锁");
            synchronized (locker) {
                System.out.println("第二次上锁");
            }
        }

按照之前对于锁的设定, 第一次加锁的时候，加锁成功。
第二次加锁的时候, 因为锁已经被占用了，如果让成功加锁，就说明是可重入锁，否则就会阻塞等待，直到外层代码执行完，锁才被释放, 但是外层代码想要执行完，必须将内层的代码执行完，而内层代码在阻塞，等外层释放锁，这时候就会死锁，就说明是不可重入锁。

类似于疫情期间的一个例子：
员工A 所在公司发明出了健康码，有一天，健康码崩了，A 需要去公司修复，但是 A 进不去公司，
因为保安说了，你得出示健康码才能进入公司，但是 A 需要先进入公司将健康码修复才能出示。

就是上述情况，如果说发生这种情况会死锁的话，就说明是不可重入锁，否则没发生死锁的话就是可重入锁。

因为 synchronized 是可重入锁，所以上述代码能正常输出：
在这里插入图片描述

在可重入锁的内部, 包含了 “线程持有者” 和 “计数器” 两个信息.

如果某个线程加锁的时候, 发现锁已经被人占用, 但是恰好占用的正是自己, 那么仍然可以继续获取到锁, 并让计数器自增.
解锁的时候计数器递减为 0 的时候, 才真正释放锁. (才能被别的线程获取到)

可重入锁的意义：
降低程序员的负担，但也带来代价，程序中会有更高的开销，需要维护锁被哪个线程占用，并且加减计数器，降低了运行效率。

二. synchronized 的使用

synchronized 本质上要修改指定对象的 “对象头”. 从使用角度来看, synchronized 也势必要搭配一个具体的对象来使用.

1. 直接修饰普通方法

对类的实例对象加锁（锁加在了 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);
    }
}

在这里插入图片描述

2. 修饰静态方法

针对类对象加锁

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();
    }
}

3. 修饰代码块

需要明确指定锁哪个对象.

针对当前对象加锁

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();
    }
}