深入理解 Java 中的 `synchronized`

简介

在多线程编程的世界里，数据的一致性和线程安全是至关重要的问题。Java 中的 synchronized 关键字就是为了解决这些问题而存在的。它提供了一种简单而强大的机制，用于控制对共享资源的访问，确保在同一时刻只有一个线程能够访问被 synchronized 修饰的代码块或方法，从而避免数据竞争和其他线程安全问题。本文将详细介绍 synchronized 的基础概念、使用方法、常见实践以及最佳实践，帮助你更好地掌握这一重要的 Java 特性。

基础概念
- 线程安全与数据竞争
- 监视器（Monitor）
使用方法
- 修饰实例方法
- 修饰静态方法
- 修饰代码块
常见实践
- 实现线程安全的单例模式
- 解决多线程环境下的资源竞争问题
最佳实践
- 缩小同步范围
- 避免死锁
- 合理选择锁对象
小结
参考资料

基础概念

线程安全与数据竞争

在多线程环境中，当多个线程同时访问和修改共享资源时，可能会导致数据竞争（Data Race）问题。数据竞争会使程序的行为变得不可预测，产生难以调试的错误。线程安全则是指一个类或对象在多线程环境下能够正确地工作，不会因为多线程的并发访问而出现错误。

监视器（Monitor）

Java 中的 synchronized 是基于监视器（Monitor）机制实现的。每个对象都有一个关联的监视器，当一个线程访问被 synchronized 修饰的代码块或方法时，它必须先获取该对象的监视器锁。只有获取到锁的线程才能进入同步区域执行代码，其他线程则会被阻塞，直到锁被释放。

使用方法

修饰实例方法

当 synchronized 修饰一个实例方法时，该方法在同一时刻只能被一个线程访问。访问该方法的线程会自动获取该实例对象的监视器锁。

public class SynchronizedInstanceMethodExample {
    private int count = 0;

    public synchronized void increment() {
        count++;
    }

    public int getCount() {
        return count;
    }
}

在上述示例中，increment 方法被声明为 synchronized，这意味着在任何时刻，只有一个线程可以调用这个方法，从而保证了 count 变量的线程安全。

修饰静态方法

当 synchronized 修饰一个静态方法时，该方法在同一时刻只能被一个线程访问。与实例方法不同的是，静态方法的锁是类对象（Class）的监视器锁。

public class SynchronizedStaticMethodExample {
    private static int count = 0;

    public static synchronized void increment() {
        count++;
    }

    public static int getCount() {
        return count;
    }
}

在这个例子中，increment 是一个静态的 synchronized 方法，锁是 SynchronizedStaticMethodExample.class 对象的监视器锁，因此所有调用该方法的线程都会竞争这个类对象的锁。

修饰代码块

Synchronized 还可以用于修饰代码块，这种方式允许更细粒度的同步控制。你可以选择一个特定的对象作为锁对象，而不是使用实例对象或类对象的锁。

public class SynchronizedBlockExample {
    private int count = 0;
    private final Object lock = new Object();

    public void increment() {
        synchronized (lock) {
            count++;
        }
    }

    public int getCount() {
        return count;
    }
}

在上述代码中，increment 方法中的 synchronized 块使用了一个单独的 lock 对象作为锁。只有获取到 lock 对象监视器锁的线程才能执行块内的代码，这种方式可以在需要更精确控制同步范围时使用。

常见实践

实现线程安全的单例模式

单例模式是一种创建型设计模式，确保一个类只有一个实例，并提供一个全局访问点来访问这个实例。在多线程环境下，实现线程安全的单例模式是一个常见的需求，synchronized 关键字可以帮助我们实现这一点。

public class ThreadSafeSingleton {
    private static ThreadSafeSingleton instance;

    private ThreadSafeSingleton() {}

    public static synchronized ThreadSafeSingleton getInstance() {
        if (instance == null) {
            instance = new ThreadSafeSingleton();
        }
        return instance;
    }
}

在上述代码中，getInstance 方法被声明为 synchronized，这确保了在多线程环境下，只有一个线程可以同时调用该方法，从而避免了多个线程同时创建实例的问题。

解决多线程环境下的资源竞争问题

在多线程环境中，多个线程可能会同时访问和修改共享资源，导致数据不一致。使用 synchronized 可以解决这种资源竞争问题。

public class Resource {
    private int value;

    public Resource(int initialValue) {
        this.value = initialValue;
    }

    public synchronized void increment() {
        value++;
    }

    public synchronized void decrement() {
        value--;
    }

    public int getValue() {
        return value;
    }
}

public class ThreadExample extends Thread {
    private Resource resource;

    public ThreadExample(Resource resource) {
        this.resource = resource;
    }

    @Override
    public void run() {
        for (int i = 0; i < 1000; i++) {
            resource.increment();
        }
    }
}

public class Main {
    public static void main(String[] args) throws InterruptedException {
        Resource resource = new Resource(0);
        Thread thread1 = new ThreadExample(resource);
        Thread thread2 = new ThreadExample(resource);

        thread1.start();
        thread2.start();

        thread1.join();
        thread2.join();

        System.out.println("Final value: " + resource.getValue());
    }
}

在上述示例中，Resource 类中的 increment 和 decrement 方法都被声明为 synchronized，这保证了在多线程环境下对 value 变量的操作是线程安全的。

最佳实践

缩小同步范围

尽量缩小 synchronized 代码块或方法的范围，只将需要同步的关键代码放在同步区域内。这样可以提高并发性能，减少线程等待的时间。

public class SynchronizedBestPractice {
    private int count = 0;
    private final Object lock = new Object();

    public void increment() {
        // 非关键代码，不需要同步
        //...

        synchronized (lock) {
            count++;
        }

        // 非关键代码，不需要同步
        //...
    }
}

避免死锁

死锁是多线程编程中一个常见的问题，当两个或多个线程相互等待对方释放锁时，就会发生死锁。为了避免死锁，应该遵循以下原则： - 尽量减少锁的嵌套使用。 - 确保线程获取锁的顺序一致。 - 使用定时锁（如 tryLock 方法）来避免无限期等待。

合理选择锁对象

选择合适的锁对象对于性能和代码的可读性都非常重要。通常，应该选择一个与同步操作相关的对象作为锁对象，避免使用 this 或 Class 对象作为锁对象，除非有明确的需求。

public class ProperLockObjectExample {
    private int count = 0;
    private final Object specificLock = new Object();

    public void increment() {
        synchronized (specificLock) {
            count++;
        }
    }
}

小结

synchronized 关键字是 Java 多线程编程中用于实现线程安全的重要工具。通过理解其基础概念、掌握不同的使用方法，并遵循最佳实践，你可以有效地解决多线程环境下的数据竞争和其他线程安全问题。在实际应用中，要根据具体的需求和场景合理使用 synchronized，以确保程序的正确性和高性能。

深入理解 Java 中的 synchronized

简介

目录