【多线程】Synchronized 用法详解

synchronized: 又叫监视器锁 monitor lock
1

一. 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 的工作过程:

1. 获得互斥锁
2. 从主内存拷贝变量的最新副本到工作的内存
3. 执行代码
4. 将更改后的共享变量的值刷新到主内存
5. 释放互斥锁

所以 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();
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

加上 synchronized，输入一个非 0 整数, t1 线程立马就能感知到，退出循环，
但是如果不加上 synchronized， 输入一个非 0 整数， t1 线程是不能感知到的，t1 还是从寄存器中读取 flag 的初始值 0， 而不是从内存中读取最新的值。

3. 可重入

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

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

        Object locker = new Object();
        synchronized (locker) {
            System.out.println("第一次上锁");
            synchronized (locker) {
                System.out.println("第二次上锁");
            }
        }
1
2
3
4
5
6
7

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

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

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

因为 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();
    }
}
1
2
3
4
5
6
7
8
9
10

针对 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);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

2. 修饰静态方法

针对类对象加锁

public class SynchronizedDemo {
    public synchronized static void method() {
    }
}
1
2
3
4

这个等价于：

public class SynchronizedDemo {
    public static void method() {
        synchronized (SynchronizedDemo.class) {

        }
    }
}
1
2
3
4
5
6
7

都是针对：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();
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

3. 修饰代码块

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

• 针对当前对象加锁

public class SynchronizedDemo {
    public void method() {
        synchronized (this) {

        }
    }
}
1
2
3
4
5
6
7

• 针对类对象加锁

public class SynchronizedDemo {
    public void method() {
        synchronized (SynchronizedDemo.class) {
        }
    }
}
1
2
3
4
5
6

• 自己创建一个锁对象

class SynchronizedDemo {
    public void method() {
        Object locker = new Object();
        synchronized (locker) {

        }
    }
}
1
2
3
4
5
6
7
8

锁竞争的例子：

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();
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36

注意：
两个线程竞争同一把锁, 才会产生阻塞等待.
两个线程分别尝试获取两把不同的锁, 不会产生竞争.

不能无脑使用 synchronized ：

• synchronized 的使用是要付出代价的，一旦使用 synchronized 就很容易造成线程阻塞，一旦线程阻塞（释放 CPU），下次再被调度到 CPU 上执行的时间就不可控了，自然就会拖慢任务的执行

• 一旦使用了 synchronized，基本就和 “高性能” 无缘了。

三. Java 标准库中的线程安全类

Java 标准库中很多都是线程不安全的. 这些类可能会涉及到多线程修改共享数据, 又没有任何加锁措施.

• ArrayList
• LinkedList
• HashMap
• TreeMap
• HashSet
• TreeSet
• StringBuilder

还有一些是线程安全的. 使用了一些锁机制来控制.

• Vector (不推荐使用)
• HashTable (不推荐使用)
• CopyOnWriteArrayList
• BlockingQueue
• CopyOnWriteArraySet
• ConcurrentHashMap
• StringBuffer (StringBuffer 的核心方法都带有 synchronized . )

还有的虽然没有加锁, 但是不涉及 “修改”, 仍然是线程安全的

• String (因为 String 是不可变对象，无法被修改，具体原因可见：String 详解)

不推荐使用 Vector 和 HashTable 就是因为它们无脑使用 synchronized，性能低。

好啦！ 以上就是对 synchronized 的用法详解，希望能帮到你 ！
评论区欢迎指正 !