在Java多线程编程场景中，当多个线程同时操作共享资源时，很容易出现数据不一致的问题，synchronized关键字就是Java提供的原生线程同步解决方案，其核心是通过锁机制保证同一时间只有一个线程能执行被保护的代码逻辑。同步代码块和同步方法是synchronized的两种常见使用形式，二者的锁对象选择规则存在明显差异，直接影响同步效果。
synchronized的基本使用形式
同步方法
同步方法是将synchronized关键字直接修饰在方法上，分为实例同步方法和静态同步方法两种类型，二者的锁对象有默认规则。
实例同步方法的锁对象是当前对象实例，也就是调用该方法的对象本身，不同实例调用的实例同步方法不会互相阻塞。
public class SyncMethodDemo {
private int count = 0;
// 实例同步方法，锁对象为当前实例this
public synchronized void increment() {
count++;
System.out.println(Thread.currentThread().getName() + " 执行后count值：" + count);
}
public static void main(String[] args) {
SyncMethodDemo demo = new SyncMethodDemo();
// 创建两个线程调用同一个实例的increment方法
Thread t1 = new Thread(() -> {
for (int i = 0; i < 3; i++) {
demo.increment();
}
}, "线程A");
Thread t2 = new Thread(() -> {
for (int i = 0; i < 3; i++) {
demo.increment();
}
}, "线程B");
t1.start();
t2.start();
}
}
静态同步方法的锁对象是当前类的Class对象，所有该类的实例调用静态同步方法时，使用的是同一个锁对象，因此会互相阻塞。
public class StaticSyncMethodDemo {
private static int staticCount = 0;
// 静态同步方法，锁对象为StaticSyncMethodDemo.class
public static synchronized void staticIncrement() {
staticCount++;
System.out.println(Thread.currentThread().getName() + " 执行后staticCount值：" + staticCount);
}
public static void main(String[] args) {
// 创建两个不同实例调用静态同步方法
StaticSyncMethodDemo demo1 = new StaticSyncMethodDemo();
StaticSyncMethodDemo demo2 = new StaticSyncMethodDemo();
Thread t1 = new Thread(() -> {
for (int i = 0; i < 3; i++) {
demo1.staticIncrement();
}
}, "线程A");
Thread t2 = new Thread(() -> {
for (int i = 0; i < 3; i++) {
demo2.staticIncrement();
}
}, "线程B");
t1.start();
t2.start();
}
}
同步代码块
同步代码块是通过synchronized(锁对象) { 代码逻辑 }的形式定义，开发者可以自定义锁对象，灵活性更高。
public class SyncBlockDemo {
private int count = 0;
// 自定义锁对象
private final Object lock = new Object();
public void increment() {
// 使用自定义的lock对象作为锁
synchronized (lock) {
count++;
System.out.println(Thread.currentThread().getName() + " 执行后count值：" + count);
}
}
public static void main(String[] args) {
SyncBlockDemo demo = new SyncBlockDemo();
Thread t1 = new Thread(() -> {
for (int i = 0; i < 3; i++) {
demo.increment();
}
}, "线程A");
Thread t2 = new Thread(() -> {
for (int i = 0; i < 3; i++) {
demo.increment();
}
}, "线程B");
t1.start();
t2.start();
}
}
同步代码块与同步方法的锁对象差异对比
两种用法的锁对象规则可以通过下表清晰对比：
| 使用形式 | 锁对象默认规则 | 锁对象是否可自定义 | 适用场景 |
|---|---|---|---|
| 实例同步方法 | 当前对象实例this | 不可自定义 | 整个方法逻辑都需要同步，且希望以当前实例作为锁的场景 |
| 静态同步方法 | 当前类的Class对象 | 不可自定义 | 整个静态方法逻辑都需要同步，且希望以类作为锁的场景 |
| 同步代码块 | 无默认，需手动指定 | 可自定义任意对象 | 仅需同步部分代码逻辑，或需要灵活控制锁对象的场景 |
锁对象选择的核心原则
在实际开发中选择锁对象时，需要遵循以下核心原则：
- 锁对象必须是共享的：如果多个线程使用的锁对象不是同一个，那么同步机制会完全失效。比如如果在同步代码块中每次都new一个Object作为锁，那么每个线程的锁都不同，无法起到同步作用。
- 锁对象尽量细化：同步代码块的锁对象可以只保护需要同步的共享资源，而不需要像同步方法那样把整个方法都锁住，这样可以减少锁的持有时间，提升并发性能。
- 避免锁对象被修改：锁对象如果被修改，那么不同线程可能拿到不同的锁引用，导致同步失效，因此自定义锁对象通常会用final修饰，保证引用不可变。
常见错误示例
以下是锁对象选择错误的常见案例：
public class WrongLockDemo {
private int count = 0;
public void wrongIncrement() {
// 错误：每次调用方法都new一个新的Object作为锁，锁对象不共享
Object lock = new Object();
synchronized (lock) {
count++;
System.out.println(Thread.currentThread().getName() + " 执行后count值：" + count);
}
}
public static void main(String[] args) {
WrongLockDemo demo = new WrongLockDemo();
Thread t1 = new Thread(() -> {
for (int i = 0; i < 3; i++) {
demo.wrongIncrement();
}
}, "线程A");
Thread t2 = new Thread(() -> {
for (int i = 0; i < 3; i++) {
demo.wrongIncrement();
}
}, "线程B");
t1.start();
t2.start();
}
}
上述代码中，每个线程调用wrongIncrement方法时都会创建一个新的Object作为锁，因此两个线程的锁互不相同，同步完全失效，最终count的结果可能出现重复或者不符合预期的情况。
总结
synchronized的两种使用形式中，同步方法的锁对象是固定的，实例方法锁为this，静态方法锁为类的Class对象，无法自定义；同步代码块可以自定义任意对象作为锁，灵活性更高。选择锁对象时核心要保证锁的共享性和不可变性，根据同步范围的大小选择合适的用法，才能在保证线程安全的同时，尽可能提升程序的并发性能。
synchronized同步代码块同步方法锁对象Java多线程修改时间：2026-06-23 07:18:17