Java语法基础中synchronized关键字有哪些用法

在Java多线程开发中，当多个线程同时操作共享资源时，很容易出现数据不一致的问题，synchronized关键字就是用来解决这类线程安全问题的核心工具，它可以通过加锁的方式保证同一时间只有一个线程能执行特定代码段。

synchronized关键字的核心作用

synchronized关键字的核心是实现线程之间的同步，它的底层是基于对象的内置锁（也叫监视器锁，Monitor）实现的。当一个线程获取到某个对象的锁之后，其他尝试获取同一个对象锁的线程就会被阻塞，直到持有锁的线程释放锁，这样就保证了被synchronized包裹的代码段在同一时间只能被一个线程执行，避免了并发操作共享资源带来的数据错误。

synchronized的三种常见用法

1. 修饰实例方法

当synchronized修饰实例方法时，锁对象是当前实例对象（也就是this）。也就是说，同一个实例的多个线程调用这个同步实例方法时，会互斥执行；而不同实例的线程调用该方法时，因为锁对象不同，不会互相影响。

public class SynchronizedDemo {
    private int count = 0;

    // 修饰实例方法，锁对象是当前实例this
    public synchronized void increment() {
        count++;
        System.out.println(Thread.currentThread().getName() + " 执行后count值：" + count);
    }

    public static void main(String[] args) {
        SynchronizedDemo demo = new SynchronizedDemo();
        // 创建两个线程操作同一个实例的increment方法
        Thread t1 = new Thread(() -> {
            for (int i = 0; i < 5; i++) {
                demo.increment();
            }
        }, "线程A");
        Thread t2 = new Thread(() -> {
            for (int i = 0; i < 5; i++) {
                demo.increment();
            }
        }, "线程B");
        t1.start();
        t2.start();
    }
}

2. 修饰静态方法

当synchronized修饰静态方法时，锁对象是当前类的Class对象。因为Class对象是全局唯一的，所以不管创建多少个类的实例，所有线程调用这个静态同步方法时，都会竞争同一把锁，从而实现全局的同步效果。

public class SynchronizedStaticDemo {
    private static int staticCount = 0;

    // 修饰静态方法，锁对象是SynchronizedStaticDemo.class
    public static synchronized void staticIncrement() {
        staticCount++;
        System.out.println(Thread.currentThread().getName() + " 执行后staticCount值：" + staticCount);
    }

    public static void main(String[] args) {
        // 创建两个不同的实例
        SynchronizedStaticDemo demo1 = new SynchronizedStaticDemo();
        SynchronizedStaticDemo demo2 = new SynchronizedStaticDemo();
        // 两个线程分别用不同实例调用静态方法
        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();
    }
}

3. 修饰代码块

修饰代码块是synchronized更灵活的使用方式，我们可以手动指定锁对象，语法是synchronized(锁对象) { 需要同步的代码 }。这种方式可以减少同步的范围，提升程序的执行效率，因为只需要把操作共享资源的核心代码放在同步块中即可。

public class SynchronizedBlockDemo {
    private int count = 0;
    // 自定义锁对象，推荐使用专用对象作为锁，不要用字符串或者包装类
    private final Object lock = new Object();

    public void increment() {
        // 其他不需要同步的代码可以在同步块外部
        long startTime = System.currentTimeMillis();
        // 同步代码块，锁对象是我们自定义的lock对象
        synchronized (lock) {
            count++;
            System.out.println(Thread.currentThread().getName() + " 执行后count值：" + count);
        }
        // 其他不需要同步的代码
        long endTime = System.currentTimeMillis();
        System.out.println(Thread.currentThread().getName() + " 执行耗时：" + (endTime - startTime) + "ms");
    }

    public static void main(String[] args) {
        SynchronizedBlockDemo demo = new SynchronizedBlockDemo();
        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();
    }
}

不同用法的锁对象对比

为了更清晰地区分三种用法的锁对象差异，我们可以通过下面的表格对比：

使用注意事项

• 尽量不要用字符串或者基础类型的包装类作为锁对象，因为这些对象可能存在常量池复用的问题，导致意想不到的锁竞争。
• 同步的范围不宜过大，否则会导致大量线程阻塞，降低程序的并发性能，尽量只把操作共享资源的代码放在同步范围内。
• synchronized是重量级锁吗？在Java 6之后，synchronized做了很多优化，比如偏向锁、轻量级锁、自旋锁等，已经不再是纯粹的重量级锁，性能有了很大提升。

synchronizedJava多线程同步锁线程安全修改时间：2026-06-06 06:32:54