Java并发控制工具：Lock与Semaphore实战应用案例

原创刺骨的言语ヽ痛彻心扉 2024-12-07 13:09 0阅读 0赞

在Java编程中，Lock和Semaphore是两种常用的并发控制工具。它们主要用于限制同时访问资源的线程数量。

1. Lock实战应用：
Lock提供独占锁（ExclusiveLock）和共享锁（SharedLock）。独占锁确保同一时间只有一个线程拥有锁，其他线程必须等待锁被释放。共享锁则允许多个线程同时持有锁，但每个线程只能访问与锁相关联的代码。

例子：
```java
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

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

public void exclusiveLock() throws InterruptedException {
        lock.lock();
        System.out.println("Exclusive lock acquired.");
        try {
            // Do some exclusive work here
        } finally {
            lock.unlock();
            System.out.println("Exclusive lock released.");
        }
    }

public void sharedLock() throws InterruptedException {
        lock.lockShared();
        System.out.println("Shared lock acquired.");
        try {
            // Do some shared work here
        } finally {
            lock.unlockShared();
            System.out.println("Shared lock released.");
        }
    }

public static void main(String[] args) {
        LockExample example = new LockExample();
        example.exclusiveLock();  // Acquire exclusive lock
        example.sharedLock();   // Acquire shared lock
        example.lock.unlock();   // Unlock both locks
    }
}
```
2. Semaphore实战应用：
Semaphore是一种信号量，可以限制同时访问资源的线程数量。它的值最小为0（无线程），最大取决于初始化时设置的最大值。

例子：
```java
import java.util.concurrent.Semaphore;

public class SemaphoreExample {
    private final Semaphore semaphore = new Semaphore(1); // Initialize with max 1

public void acquireSemaphore() throws InterruptedException {
        semaphore.acquire();  // Acquire semaphore lock
        System.out.println("Semaphore acquired.");
        try {
            // Do some work controlled by the semaphore
        } finally {
            semaphore.release();  // Release semaphore lock
            System.out.println("Semaphore released.");
        }
    }

public static void main(String[] args) {
        SemaphoreExample example = new SemaphoreExample();
        example.acquireSemaphore();  // Acquire semaphore
        example.releaseSemaphore();   // Release semaphore
    }
}
```
总结，Lock和Semaphore都是Java中常用的并发控制工具。在应用时，需要根据具体需求选择合适的锁或信号量。