java synchronized关键字介绍

Java 中的 synchronized 关键字用于实现线程安全，防止多个线程同时访问共享资源时出现数据不一致的问题。它可以用来修饰方法或者代码块，确保在同一时刻最多只有一个线程执行被 synchronized 修饰的代码。

使用场景

1. 同步实例方法：确保同一实例的同步方法在同一时刻只能被一个线程访问。
2. 同步静态方法：确保同一类的静态同步方法在同一时刻只能被一个线程访问。
3. 同步代码块：提供更细粒度的控制，锁定指定对象。

1. 同步实例方法

使用 synchronized 修饰实例方法，表示整个方法是同步的，锁定当前实例 (this)。

public class Counter {
    private int count = 0;

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

    public int getCount() {
        return count;
    }
}

在上述例子中，increment 方法是同步的，意味着同一时刻最多只有一个线程可以执行它。

2. 同步静态方法

使用 synchronized 修饰静态方法，表示整个方法是同步的，锁定的是类对象 (Class)，而不是实例对象。

public class Counter {
    private static int count = 0;

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

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

在这个例子中，increment 静态方法是同步的，意味着同一时刻最多只有一个线程可以执行它。

3. 同步代码块

使用 synchronized 修饰代码块，可以锁定任意对象，实现更细粒度的同步控制。

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

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

    public int getCount() {
        return count;
    }
}

在这个例子中，synchronized 代码块锁定了 lock 对象，只在需要同步的部分进行同步控制，而不是整个方法。

工作原理

Java 中的每个对象都有一个内部锁 (或监视器)，当一个线程进入 synchronized 方法或代码块时，它会获取该对象的锁。当另一个线程试图进入相同对象的其他 synchronized 方法或代码块时，它必须等待直到第一个线程释放锁。

• 对象锁：用于实例方法和实例代码块。
• 类锁：用于静态方法和静态代码块。

注意事项

1. 避免死锁：不当使用 synchronized 可能导致死锁。死锁发生在两个或多个线程互相等待对方持有的锁，从而都无法继续执行。
2. 减少锁的粒度：尽量减少锁定的范围，只在必要的代码块上使用 synchronized，避免锁定整个方法，减少性能开销。
3. 考虑使用其他并发工具：在某些情况下，java.util.concurrent 包提供的工具（如 ReentrantLock、ReadWriteLock 等）比 synchronized 更灵活和高效。

示例

下面是一个多线程计数器的示例，使用 synchronized 实现线程安全：

public class Counter {
    private int count = 0;

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

    public synchronized int getCount() {
        return count;
    }

    public static void main(String[] args) throws InterruptedException {
        Counter counter = new Counter();
        Thread t1 = new Thread(() -> {
            for (int i = 0; i < 1000; i++) {
                counter.increment();
            }
        });

        Thread t2 = new Thread(() -> {
            for (int i = 0; i < 1000; i++) {
                counter.increment();
            }
        });

        t1.start();
        t2.start();
        t1.join();
        t2.join();

        System.out.println("Final count: " + counter.getCount());
    }
}

这个示例中，我们创建了两个线程，每个线程对计数器调用 1000 次 increment 方法。由于 increment 方法被 synchronized 修饰，它在同一时刻只能被一个线程访问，从而保证了计数器的线程安全性。最终输出的计数器值将是 2000。