引言

在并发编程中，数据共享是一个常见的问题。如果多个线程同时访问共享数据，可能会引发数据不一致的问题。Java 提供了多种方式来解决这些问题，其中最基本也是最常用的方式之一就是使用 synchronized 关键字。本文将详细介绍 synchronized 的使用方法、应用场景及其工作原理。

什么是 synchronized

synchronized 关键字用于在多线程环境中对资源进行加锁，以确保同一时刻只有一个线程能够访问该资源。这种机制避免了多个线程同时修改共享资源，从而导致数据不一致的问题。

synchronized 的基本使用

synchronized 可以用于方法和代码块，具体用法如下：

同步实例方法

将整个方法声明为同步方法，这意味着每次只能有一个线程访问该方法：

public class Counter {
    private int count = 0;

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

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

在上述代码中，increment 和 getCount 方法都是同步方法。如果一个线程正在执行 increment 方法，其他线程将无法访问 increment 和 getCount 方法，直到该线程执行完毕。

同步代码块

同步代码块可以用来细粒度地控制同步逻辑，仅对特定部分代码进行同步：

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

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

    public int getCount() {
        synchronized (lock) {
            return count;
        }
    }
}

在上述代码中，只有 synchronized 块内的代码是同步的。这种方式允许更灵活地控制同步范围，并且可以使用不同的锁对象。

同步静态方法

将静态方法声明为同步方法，这意味着每次只能有一个线程访问该静态方法：

public class StaticCounter {
    private static int count = 0;

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

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

在上述代码中，increment 和 getCount 是同步静态方法，锁定的是类对象（StaticCounter.class）。

同步静态代码块

静态代码块可以用于对静态方法中的某些部分进行同步：

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

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

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

在上述代码中，静态方法中的代码块使用 synchronized 进行同步，锁定的是一个静态锁对象。

synchronized 的工作原理

synchronized 通过内置的监视器锁（monitor lock 或 intrinsic lock）实现同步。每个对象都有一个监视器锁，线程进入同步代码块或方法时需要先获得该锁。获得锁的线程可以继续执行，而其他线程将被阻塞，直到锁被释放。

锁的重入性

synchronized 是可重入锁，这意味着如果一个线程已经获得了对象的锁，那么它可以再次进入由同一对象锁保护的同步代码块，而不会被阻塞。

public class ReentrantExample {
    public synchronized void method1() {
        method2();
    }

    public synchronized void method2() {
        // do something
    }
}

在上述代码中，method1 可以调用 method2 而不会引发死锁，因为同一线程可以重新获得锁。

使用场景

计数器

常见的使用场景之一是计数器，确保多个线程正确更新计数值：

public class Counter {
    private int count = 0;

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

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

单例模式

在单例模式中，确保在多线程环境中正确创建单例对象：

public class Singleton {
    private static Singleton instance;

    private Singleton() {}

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

线程安全集合

在需要确保集合线程安全的场景下，可以使用同步代码块：

import java.util.*;

public class ThreadSafeList {
    private List<Integer> list = new ArrayList<>();

    public void add(Integer value) {
        synchronized (this) {
            list.add(value);
        }
    }

    public int size() {
        synchronized (this) {
            return list.size();
        }
    }
}

注意事项

性能问题

使用 synchronized 会导致性能开销，特别是在高并发环境下，过多的锁竞争会导致线程阻塞和上下文切换。应尽量缩小同步代码块的范围，并避免不必要的同步。

死锁

不当的使用 synchronized 可能导致死锁。例如，线程 A 持有锁 1 并等待锁 2，而线程 B 持有锁 2 并等待锁 1：

public class DeadlockExample {
    private final Object lock1 = new Object();
    private final Object lock2 = new Object();

    public void method1() {
        synchronized (lock1) {
            synchronized (lock2) {
                // do something
            }
        }
    }

    public void method2() {
        synchronized (lock2) {
            synchronized (lock1) {
                // do something
            }
        }
    }
}

在上述代码中，如果 method1 和 method2 分别由不同的线程调用，可能会导致死锁。

结论

synchronized 是 Java 并发编程中一种基础且重要的工具，用于确保线程安全。通过适当使用 synchronized 关键字，可以有效避免多线程环境中的数据不一致问题。然而，在使用时需要谨慎考虑性能开销和潜在的死锁问题。了解并掌握 synchronized 的使用，可以帮助你在编写并发程序时做出更好的设计和实现。

希望本文能帮助你理解 synchronized 关键字的工作原理及其使用方法。如果你有任何问题或建议，欢迎留言讨论。