线程同步：Java的synchronized关键字实例分析

原创待我称王封你为后i 2024-09-18 00:36 68阅读 0赞

在Java编程中，线程同步是为了确保在同一时刻只有一个线程能够访问和修改共享资源。以下是使用`synchronized`关键字进行线程同步的实例分析：

1. **简单锁**：
   ```java
   public class Counter {
       private int count = 0;

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

public synchronized int decrement() {
           if (count > 0) {
               count--;
               return count;
           } else {
               throw new RuntimeException("Counter underflow");
           }
       }

public synchronized int getCount() {
           return count;
       }
   }
   ```
   在这里，`increment()`、`decrement()`和`getCount()`方法都进行了同步。这样可以确保在同一时刻只有一个线程能够操作共享的计数器。

2. **公平锁**（如ReentrantLock）：
   ```java
   import java.util.concurrent.locks.ReentrantLock;

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

public void increment() {
           lock.lock();
           try {
               count++;
           } finally {
               lock.unlock();
           }
       }

public int decrement() {
           lock.lock();
           try {
               if (count > 0) {
                   count--;
                   return count;
               } else {
                   throw new RuntimeException("Counter underflow");
               }
           } finally {
               lock.unlock();
           }
       }

public int getCount() {
           lock.lock();
           try {
               return count;
           } finally {
               lock.unlock();
           }
       }
   }
   ```
   在这里，`increment()`、`decrement()`和`getCount()`方法都通过了ReentrantLock的锁保护。这样可以确保在任何时候只有一个线程能够修改共享计数器。

总结，Java中的`synchronized`关键字主要用于实现线程同步，确保多线程环境下的数据一致性。