理解和优化Java中的同步代码：锁和并发工具实例

原创我就是我 2024-10-24 09:00 9阅读 0赞

在Java中，同步代码主要是通过锁（Lock）和其他并发工具来实现的。以下是一些常见的锁和并发工具实例：

1. **synchronized关键字**：
   - 示例：
     ```java
     class Counter {
         private int count = 0;
         
         public synchronized void increment() {
             count++;
         }
         
         public synchronized int getCount() {
             return count;
         }
     }
     ```
   - 这里的`synchronized`确保同一时间只有一个线程能够访问到`increment`或`getCount`方法。

2. **ReentrantLock**：
   - 示例：
     ```java
     import java.util.concurrent.locks.ReentrantLock;

class ExclusiveResource {
         private final ReentrantLock lock = new ReentrantLock();

public void acquireExclusive() {
             try {
                 lock.acquire();
                 System.out.println("Acquired exclusive resource.");
             } catch (InterruptedException e) {
                 e.printStackTrace();
             }
         }

public void releaseExclusive() {
             try {
                 lock.release();
                 System.out.println("Released exclusive resource.");
             } catch (Exception e) {
                 e.printStackTrace();
             }
         }
     }
     ```
   - 这里的`ReentrantLock`提供了比`synchronized`更细粒度的锁控制。

3. **Semaphore**：
   - 示例：
     ```java
     import java.util.concurrent.Semaphore;

class ConcurrentResource {
         private final Semaphore semaphore = new Semaphore(1);

public void acquireShared() {
             try {
                 semaphore.acquire();
                 System.out.println("Acquired shared resource.");
             } catch (InterruptedException e) {
                 e.printStackTrace();
             }
         }

public void releaseShared() {
             try {
                 semaphore.release();
                 System.out.println("Released shared resource.");
             } catch (Exception e) {
                 e.printStackTrace();
             }
         }
     }
     ```
   - 这里的`Semaphore`可以用来控制同时访问资源的线程数量，实现更细粒度的并发控制。

总结：理解Java中的同步代码主要是通过锁（如ReentrantLock）和其他并发工具来实现。这些工具提供了不同级别的并发控制和资源管理。