使用 synchronized、AtomicInteger 和 ReentrantLock 的简单示例

import java.util.concurrent.atomic.AtomicInteger;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class SynchronizationDemo {
    private static int count = 0;
    private static AtomicInteger atomicCount = new AtomicInteger(0);
    private static Lock lock = new ReentrantLock();

    public static void main(String[] args) throws InterruptedException {
        // 创建多个线程进行增加操作
        Thread[] threads = new Thread[5];
        for (int i = 0; i < threads.length; i++) {
            threads[i] = new Thread(() -> {
                // 使用 synchronized 关键字保证线程安全
                synchronized (SynchronizationDemo.class) {
                    count++;
                    System.out.println("Count: " + count);
                }
                // 使用 Atomic 原子类保证线程安全
                int newValue = atomicCount.incrementAndGet();
                System.out.println("Atomic Count: " + newValue);

                // 使用 ReentrantLock 实现线程安全
                lock.lock();

                                try {
                    count++;
                    System.out.println("Lock Count: " + count);
                } finally {
                    lock.unlock();
                }
            });
            threads[i].start();
        }

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

在上述示例中，我们创建了多个线程对 count 进行增加操作。使用 synchronized 关键字保证了 count 的线程安全性，而 AtomicInteger 类提供了原子操作来保证 atomicCount 的线程安全性。另外，使用 ReentrantLock 实现了对 count 的线程安全访问。

请注意，这只是一个简单的示例，以展示不同的同步机制。在实际应用中，需要根据具体的需求和场景选择合适的同步机制。

哪种同步机制比较好，需要根据具体的需求和场景来选择。

上述方法哪种比较好？

synchronized 关键字使用简单，可以保证线程安全，但是可能会出现死锁或性能问题。Atomic 类提供了原子操作，可以在没有显式锁的情况下实现线程安全，但是只能用于基本类型数据的原子操作，并且对复杂的操作不够灵活。Lock 接口及其实现类提供了更高级别的同步机制，可以手动控制锁的获取和释放，并提供更高级别的功能，例如可重入锁、公平锁等，但是相对于简单的 synchronized 关键字，它们可能需要更多的编码和维护工作。

因此，在选择使用何种同步机制时，需要根据具体情况和需求来进行权衡。一般来说，如果只是简单的线程同步，使用 synchronized 关键字已经足够。如果需要进行更细粒度的控制或者有特殊的需求，可以考虑使用 Atomic 类或者 Lock 接口及其实现类。