Java synchronized案例怎么用

wen java案例 2026-07-01 272

Java synchronized案例怎么用：从入门到实战的完整指南

目录导读

synchronized核心概念速览
基础用法案例：同步方法与同步块
经典实战：多线程卖票系统
进阶陷阱：错误使用案例与修正
性能对比：synchronized vs Lock
常见问答FAQ
总结与最佳实践

synchronized核心概念速览

Q: synchronized到底锁的是什么？
A: 锁的是对象实例或Class对象。

Java synchronized案例怎么用

修饰实例方法：锁当前实例this
修饰静态方法：锁当前类的Class对象
修饰代码块：锁括号内指定的对象

关键原则：多个线程必须竞争同一把锁才能实现互斥，如果锁不同,synchronized将失效。

基础用法案例：同步方法与同步块

案例1：同步实例方法

public class Counter {
    private int count = 0;
    public synchronized void increment() { count++; }
    // 等价于 synchronized(this) { count++; }
}

适用场景：整个方法都需要同步,且锁对象明确。

案例2：同步静态方法

public class StaticCounter {
    private static int count = 0;
    public static synchronized void increment() { count++; }
    // 锁Class对象，所有实例共享同一把锁
}

案例3：同步代码块（精准锁定）

public class FineGrainedLock {
    private final Object lock = new Object();
    public void method() {
        // 非同步代码...
        synchronized (lock) {
            // 仅同步临界区代码
        }
    }
}

优势：缩小同步范围,提升并发性能。

经典实战：多线程卖票系统

问题描述

模拟3个窗口同时卖100张票，要求：

不能超卖（同一张票不能卖两次）
最终剩余票数为0

错误实现（线程不安全）

class Ticket {
    private int tickets = 100;
    public void sell() {
        if (tickets > 0) {
            try { Thread.sleep(10); } catch (InterruptedException e) {}
            tickets--;
        }
    }
}
// 3个线程各卖100次，结果剩余票数可能为负数

正确实现（synchronized锁实例）

class SafeTicket {
    private int tickets = 100;
    public synchronized void sell() {  // 锁this
        if (tickets > 0) {
            try { Thread.sleep(10); } catch (InterruptedException e) {}
            tickets--;
        }
    }
}
public class Test {
    public static void main(String[] args) throws InterruptedException {
        SafeTicket ticket = new SafeTicket();
        for (int i = 0; i < 3; i++) {
            new Thread(() -> {
                while (ticket.available() > 0) {
                    ticket.sell();
                }
            }).start();
        }
    }
}

运行结果：剩余票数始终为0,无负数。

注意事项

锁必须一致：若使用SafeTicket的不同实例，锁失效
避免在锁内执行耗时I/O：会阻塞其他线程

进阶陷阱：错误使用案例与修正

陷阱1：锁字符串常量

// 错误：字符串常量池导致不同对象共享同一锁
synchronized ("LOCK") { ... }
// 修正：使用new Object()或指定唯一对象
private final Object lock = new Object();
synchronized (lock) { ... }

陷阱2：锁Integer等包装类

// 错误：Integer缓存池（-128~127）导致锁范围扩大
Integer lock = 1;
synchronized (lock) { ... }
// 修正：使用最终常量或专用锁对象
private final Object lock = new Object();

陷阱3：synchronized与非同步混用

class Data {
    private int value;
    public synchronized void set(int v) { value = v; }
    public int get() { return value; } // 未同步！导致读取脏数据
}
// 修正：读取方法也要同步，或使用volatile+原子类

性能对比：synchronized vs Lock

特性	synchronized	Lock (ReentrantLock)
锁获取方式	隐式	显式lock()/unlock()
可中断性	不支持	支持lockInterruptibly()
公平锁	非公平	可选公平/非公平
性能	低竞争下优于Lock	高竞争下更稳定
语法简洁	自动释放锁	必须finally解锁

何时用synchronized：

同步块简单，无需高级特性
代码可读性优先
低并发场景

何时用Lock：

需要超时、可中断、尝试获取锁
需要公平锁
高并发写场景

常见问答FAQ

Q1：synchronized能锁住int吗？

A：不能，synchronized只能锁对象，int是原始类型，需用Integer包装类,但注意缓存陷阱。

Q2：静态方法用synchronized锁类，会影响实例方法吗？

A：不会，实例方法锁this，静态方法锁Class,两者互不干扰。

Q3：synchronized遇到异常会释放锁吗？

A：会，JVM自动释放锁,即使发生异常或return。

Q4：多个synchronized方法嵌套是否会导致死锁？

A：可能，例如A线程锁obj1请求obj2，B线程锁obj2请求obj1，解决方案：全局排序锁顺序。

Q5：String作为锁对象是否安全？

A：不安全，字符串常量池导致不同线程可能持有相同锁对象，用new Object()确保唯一性。

总结与最佳实践

核心原则

锁对象唯一：避免使用字符串常量、Integer缓存
锁定范围最小：能用同步块不用方法，能用代码块不用全方法
锁内的操作尽量轻量：避免I/O、网络请求等耗时操作
使用专用锁对象：声明为private final Object，避免外部干扰

代码模板

public class ThreadSafeService {
    private final Object lock = new Object();
    private final Map<String, String> cache = new HashMap<>();
    public String getData(String key) {
        // 非同步预处理
        synchronized (lock) {
            // 1. 检查缓存
            if (cache.containsKey(key)) return cache.get(key);
            // 2. 计算数据（耗时操作）
            String result = computeExpensive(key);
            // 3. 放入缓存
            cache.put(key, result);
            return result;
        }
    }
}