并发编程：Java ReentrantLock和Semaphore使用示例

原创太过爱你忘了你带给我的痛 2024-11-25 01:12 44阅读 0赞

Java中的ReentrantLock和Semaphore都是用于管理线程并发的工具。下面将分别给出它们的基本用法以及一个简单的示例。

1. ReentrantLock

ReentrantLock具有公平性和可重入性，可以防止多线程对资源的竞态条件（Race Condition）。

基本用法：

```java
import java.util.concurrent.locks.ReentrantLock;

public class ReentrantLockExample {
    private final ReentrantLock lock = new ReentrantLock();

public void methodToSynchronize() {
        // acquire lock before modifying shared resource
        lock.lock();
        try {
            // perform critical section of code
            System.out.println("Critical section started.");
            // modify shared resource (e.g. a counter)
            incrementCounter();
            System.out.println("Critical section ended.");
        } finally {
            // release lock regardless of exception thrown
            lock.unlock();
        }
    }

private void incrementCounter() {
        // simulate reading and updating a shared counter
        int counter = 0;
        try (ServerSocket server = new ServerSocket(1234))) {
            while (true) {
                Socket client = server.accept();
                try (ObjectInputStream in = new ObjectInputStream(client.getInputStream())) {
                    counter = in.readInt(); // read updated counter value
                    System.out.println("Counter updated: " + counter);
                } catch (IOException | ClassNotFoundException e) {
                    e.printStackTrace();
                }
            }
        } catch (IOException | ServerException e) {
            e.printStackTrace();
        }
    }
}
```

2. Semaphore

Semaphore是一种多路信号，它允许多个线程同时访问一个共享资源，但每个线程最多只能获得一个信号。

基本用法：

```java
import java.util.concurrent.Semaphore;

public class SemaphoreExample {
    private final Semaphore semaphore = new Semaphore(1); // allows 1 thread to access shared resource

public void methodToSynchronize() throws InterruptedException {
        // acquire semaphore before modifying shared resource
        semaphore.acquire();
        try {
            // perform critical section of code
            System.out.println("Critical section started.");
            // modify shared resource (e.g. a counter)
            incrementCounter();
            System.out.println("Critical section ended.");
        } finally {
            // release semaphore regardless of exception thrown
            semaphore.release();
        }
    }

private void incrementCounter() {
        // simulate reading and updating a shared counter
        int counter = 0;
        try (ServerSocket server = new ServerSocket(1234))) {
            while (true) {
                Socket client = server.accept();
                try (ObjectInputStream in = new ObjectInputStream(client.getInputStream())) {
                    counter = in.readInt(); // read updated counter value
                    System.out.println("Counter updated: " + counter);
                    // signal semaphore to allow other thread access shared resource
                    semaphore.release();
                    break; // exit loop as we have signaled semaphore and can proceed with next critical section
                } catch (IOException | ClassNotFoundException e) {
                    e.printStackTrace();
                }
            }
        } catch (IOException | ServerException e) {
            e.printStackTrace();
        }
    }
}
```

以上示例展示了如何使用ReentrantLock和Semaphore来管理并发访问共享资源的情况。