前言

在多线程编程中，线程同步是一个非常重要的概念。通过同步，可以确保多个线程在访问共享资源时不会发生竞态条件（Race Condition），从而保证程序的正确性和可靠性。Java 提供了多种同步机制，其中 `synchronized` 关键字是最常用的一种。

synchronized关键字概述

`synchronized` 关键字可以用于方法或代码块，用来标记需要同步的代码区域。当一个线程进入同步区域时，它将获得一个称为“内在锁”或“监视器锁”的对象锁。

• 当 `synchronized` 修饰方法时，锁的是当前实例对象。
• 当 `synchronized` 修饰静态方法时，锁的是当前类的 Class 对象。
• 当 `synchronized` 修饰代码块时，可以指定锁的对象。

案例讲解：使用synchronized实现线程安全的计数器

以下是一个使用 `synchronized` 关键字实现线程安全计数器的示例。

示例代码

public class SynchronizedCounter {
    private int count = 0;

    // 使用synchronized修饰实例方法
    public synchronized void increment() {
        count++;
    }

    // 使用synchronized修饰代码块
    public void incrementWithLock(Object lock) {
        synchronized (lock) {
            count++;
        }
    }

    public int getCount() {
        return count;
    }

    public static void main(String[] args) throws InterruptedException {
        SynchronizedCounter counter = new SynchronizedCounter();
        Object lock = new Object();

        // 创建多个线程来测试计数器是否线程安全
        Thread[] threads = new Thread[1000];
        for (int i = 0; i  {
                for (int j = 0; j < 1000; j++) {
                    // counter.increment(); // 可以使用这种方式
                    counter.incrementWithLock(lock); // 或者使用这种方式
                }
            });
            threads[i].start();
        }

        // 等待所有线程完成
        for (Thread thread : threads) {
            thread.join();
        }

        // 打印最终计数器值
        System.out.println("Final count: " + counter.getCount());
    }
}
    

代码解析

1. `SynchronizedCounter` 类中有一个 `count` 变量以及两个 `increment` 方法，一个使用 `synchronized` 修饰实例方法，另一个使用 `synchronized` 修饰代码块并接受一个锁对象。

2. 在 `main` 方法中，我们创建了 1000 个线程，每个线程对计数器执行 1000 次递增操作。通过调用 `increment` 方法或 `incrementWithLock(lock)` 方法，可以确保计数器的递增操作是线程安全的。

3. 最后，通过 `thread.join()` 方法等待所有线程完成，并打印出计数器的最终值。

总结

`synchronized` 关键字是Java中实现线程同步的重要工具之一。通过合理地使用 `synchronized`，可以确保多个线程在访问共享资源时不会发生竞态条件，从而提升程序的稳定性和可靠性。

希望本教程能对你有所帮助，祝你编程愉快！