JUC：深入理解 synchronized#

在并发编程中，synchronized 是最基础、也最常用的线程同步手段之一。本文先讲清楚「为什么需要锁」，再通过三个案例理解它的正确用法。

1. 临界区与竞态条件#

临界区（Critical Section）#

临界区是指访问共享资源（如共享变量、文件、连接等）的代码片段。这个区域在同一时刻通常只能有一个线程执行。

示例（读-改-写）：

1
temp = count      // 读取
2
temp = temp + 1   // 计算
3
count = temp      // 写回

竞态条件（Race Condition）#

当多个线程在没有同步保护的情况下交错执行临界区，程序结果就会依赖线程调度顺序，从而出现错误，这就是竞态条件。

一句话总结：临界区是风险区域，竞态条件是风险变成现实后的错误结果。

2. synchronized 能解决什么#

synchronized 是 Java 的内置监视器锁（Intrinsic Lock），主要保证：

互斥（原子性）：同一时刻只有一个线程进入受保护代码。
可见性：释放锁前对共享变量的修改，对后续获得同一把锁的线程可见。

注意：synchronized 不直接提供「公平性」保证。

3. 第一组案例：共享变量自增/自减#

非线程安全版本#

1
package demo;
2

3
import demo.annotations.NoThreadSafe;
4

5
public class InterruptSleepDemo {
6
    private static int a = 0;
7

8
    @NoThreadSafe
9
    public static void main(String[] args) throws InterruptedException {
10
        Thread t1 = new Thread(() -> {
11
            for (int i = 0; i < 100000; i++) {
12
                a++;
13
            }
14
        });
15

16
        Thread t2 = new Thread(() -> {
17
            for (int i = 0; i < 100000; i++) {
18
                a--;
19
            }
20
        });
21

22
        t1.start();
23
        t2.start();
24
        t1.join();
25
        t2.join();
26

27
        System.out.println(a);
28
    }
29
}

线程安全版本#

1
package demo;
2

3
import demo.annotations.ThreadSafe;
4

5
public class InterruptSleepDemo {
6
    private static int a = 0;
7

8
    @ThreadSafe
9
    public static void main(String[] args) throws InterruptedException {
10
        Thread t1 = new Thread(() -> {
11
            synchronized (InterruptSleepDemo.class) {
12
                for (int i = 0; i < 100000; i++) {
13
                    a++;
14
                }
15
            }
16
        });
17

18
        Thread t2 = new Thread(() -> {
19
            synchronized (InterruptSleepDemo.class) {
20
                for (int i = 0; i < 100000; i++) {
21
                    a--;
22
                }
23
            }
24
        });
25

26
        t1.start();
27
        t2.start();
28
        t1.join();
29
        t2.join();
30

31
        System.out.println(a);
32
    }
33
}

通过让两个线程竞争同一把锁（InterruptSleepDemo.class），可以保证对 a 的复合操作不被打断。

4. synchronized 加在不同位置，锁的对象不同#

写法	锁对象
`synchronized` 实例方法	当前实例（`this`）
`static synchronized` 方法	当前类的 `Class` 对象
`synchronized (obj) {}`	指定对象 `obj`

5. 第二组案例：卖票超卖问题#

非线程安全版本（会超卖）#

1
package demo;
2

3
import demo.annotations.NoThreadSafe;
4

5
import java.util.ArrayList;
6
import java.util.Collections;
7
import java.util.List;
8
import java.util.Random;
9

10
public class TicketTest {
11
    public static void main(String[] args) throws InterruptedException {
12
        TicketWindow ticketWindow = new TicketWindow(10000);
13

14
        List<Integer> list = Collections.synchronizedList(new ArrayList<>());
15
        List<Thread> threads = new ArrayList<>();
16

17
        for (int i = 0; i < 10000; i++) {
18
            Random random = new Random();
19
            Thread thread = new Thread(() -> {
20
                int want = random.nextInt(10);
21
                int sold = ticketWindow.sell(want);
22
                list.add(sold);
23
            });
24
            threads.add(thread);
25
            thread.start();
26
        }
27

28
        for (Thread t : threads) {
29
            t.join();
30
        }
31

32
        int soldTotal = list.stream().mapToInt(Integer::intValue).sum();
33
        System.out.println("最终剩余: " + ticketWindow.getCount());
34
        System.out.println("卖出统计: " + soldTotal);
35
        System.out.println("校验（剩余+卖出）: " + (ticketWindow.getCount() + soldTotal));
36
    }
37
}
38

39
class TicketWindow {
40
    private int count;
41

42
    public TicketWindow(int count) {
43
        this.count = count;
44
    }
45

46
    @NoThreadSafe
47
    public int getCount() {
48
        return count;
49
    }
50

51
    @NoThreadSafe
52
    public int sell(int amount) {
53
        if (count >= amount) {
54
            count -= amount;
55
            System.out.println("卖出" + amount + " ==== 剩余: " + count);
56
            return amount;
57
        }
58
        System.out.println("卖出0 ==== 剩余: " + count);
59
        return 0;
60
    }
61
}

问题根因：sell() 中的 if (count >= amount) + count -= amount 不是原子操作，多个线程会交错执行。

线程安全版本#

1
package demo;
2

3
import demo.annotations.ThreadSafe;
4

5
import java.util.ArrayList;
6
import java.util.Collections;
7
import java.util.List;
8
import java.util.Random;
9

10
public class TicketTest {
11
    public static void main(String[] args) throws InterruptedException {
12
        TicketWindow ticketWindow = new TicketWindow(10000);
13

14
        List<Integer> list = Collections.synchronizedList(new ArrayList<>());
15
        List<Thread> threads = new ArrayList<>();
16

17
        for (int i = 0; i < 10000; i++) {
18
            Random random = new Random();
19
            Thread thread = new Thread(() -> {
20
                int want = random.nextInt(10);
21
                int sold = ticketWindow.sell(want);
22
                list.add(sold);
23
            });
24
            threads.add(thread);
25
            thread.start();
26
        }
27

28
        for (Thread t : threads) {
29
            t.join();
30
        }
31

32
        int soldTotal = list.stream().mapToInt(Integer::intValue).sum();
33
        System.out.println("最终剩余: " + ticketWindow.getCount());
34
        System.out.println("卖出统计: " + soldTotal);
35
        System.out.println("校验（剩余+卖出）: " + (ticketWindow.getCount() + soldTotal));
36
    }
37
}
38

39
class TicketWindow {
40
    private int count;
41

42
    public TicketWindow(int count) {
43
        this.count = count;
44
    }
45

46
    @ThreadSafe
47
    public synchronized int getCount() {
48
        return count;
49
    }
50

51
    @ThreadSafe
52
    public synchronized int sell(int amount) {
53
        if (count >= amount) {
54
            count -= amount;
55
            System.out.println("卖出" + amount + " ==== 剩余: " + count);
56
            return amount;
57
        }
58
        System.out.println("卖出0 ==== 剩余: " + count);
59
        return 0;
60
    }
61
}

6. 第三组案例：转账（涉及两个对象）#

当一个操作同时涉及两个账户对象时，只锁 this 往往不够。

非线程安全版本#

1
package demo;
2

3
import java.util.ArrayList;
4
import java.util.List;
5

6
public class TransferTest {
7
    public static void main(String[] args) {
8
        Account a = new Account(10000);
9
        Account b = new Account(10000);
10
        List<Thread> threads = new ArrayList<>();
11

12
        for (int i = 0; i < 1000; i++) {
13
            Thread thread = new Thread(() -> {
14
                a.transfer(b, 1000);
15
                b.transfer(a, 1000);
16
            });
17
            thread.start();
18
            threads.add(thread);
19
        }
20

21
        for (Thread thread : threads) {
22
            try {
23
                thread.join();
24
            } catch (InterruptedException e) {
25
                Thread.currentThread().interrupt();
26
            }
27
        }
28

29
        System.out.println("a.getAmount() = " + a.getAmount());
30
        System.out.println("b.getAmount() = " + b.getAmount());
31
        System.out.println(a.getAmount() + b.getAmount());
32
    }
33
}
34

35
class Account {
36
    private long amount;
37

38
    public Account(long amount) {
39
        this.amount = amount;
40
    }
41

42
    public long getAmount() {
43
        return amount;
44
    }
45

46
    public void setAmount(long amount) {
47
        this.amount = amount;
48
    }
49

50
    public void transfer(Account target, long money) {
51
        if (this.amount >= money) {
52
            this.setAmount(this.getAmount() - money);
53
            target.setAmount(target.getAmount() + money);
54
        }
55
    }
56
}

改进版本（按固定顺序锁两个账户，避免死锁）#

你原来使用 synchronized (Account.class) 也能保证正确性，但并发度会很低（所有账户互相串行）。

1
package demo;
2

3
import demo.annotations.ThreadSafe;
4

5
class Account {
6
    private long amount;
7

8
    public Account(long amount) {
9
        this.amount = amount;
10
    }
11

12
    public long getAmount() {
13
        return amount;
14
    }
15

16
    @ThreadSafe
17
    public void transfer(Account target, long money) {
18
        if (target == null || target == this || money <= 0) {
19
            return;
20
        }
21

22
        Account first = this;
23
        Account second = target;
24

25
        if (System.identityHashCode(first) > System.identityHashCode(second)) {
26
            first = target;
27
            second = this;
28
        }
29

30
        synchronized (first) {
31
            synchronized (second) {
32
                if (this.amount >= money) {
33
                    this.amount -= money;
34
                    target.amount += money;
35
                }
36
            }
37
        }
38
    }
39
}

这种做法的优点：

正确性：同时保护两个账户余额。
安全性：固定加锁顺序，降低死锁风险。
并发性：不同账户对之间仍可并行执行，不会像类锁那样全局串行。

7. 小结#

synchronized 的核心是：同一把锁保护同一份共享状态。
只要是「读-改-写」复合操作，就要警惕竞态条件。
涉及多个共享对象时，必须设计好锁粒度和加锁顺序。

如果你正在系统学习 JUC，下一步建议对比：synchronized、ReentrantLock 与 Atomic* 的适用边界与性能差异。

分类

JUC：深入理解 synchronized#

1. 临界区与竞态条件#

临界区（Critical Section）#

竞态条件（Race Condition）#

2. synchronized 能解决什么#

3. 第一组案例：共享变量自增/自减#

非线程安全版本#

线程安全版本#

4. synchronized 加在不同位置，锁的对象不同#

5. 第二组案例：卖票超卖问题#

非线程安全版本（会超卖）#

线程安全版本#

6. 第三组案例：转账（涉及两个对象）#

非线程安全版本#

改进版本（按固定顺序锁两个账户，避免死锁）#

7. 小结#