Java并发编程：锁和信号量示例

原创 - 日理万妓 2024-11-15 11:39 10阅读 0赞

在Java并发编程中，锁（Lock）和信号量（Semaphore）都是用于线程同步的工具。

1. 锁（Lock）示例：
```java
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

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

public void methodToLock() {
        // Acquire the lock
        lock.lock();
        try {
            // Perform some critical operation
            System.out.println("Critical operation in locked method.");
        } finally {
            // Release the lock, even if an exception occurred
            lock.unlock();
        }
    }

public static void main(String[] args) {
        LockExample example = new LockExample();
        example.methodToLock();  // Acquires and releases the lock
    }
}
```
2. 信号量（Semaphore）示例：
```java
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.Semaphore;

public class SemaphoreExample {
    private final Semaphore semaphore = new Semaphore(1);  // Limit to 1 thread at a time

public void methodToControl() throws InterruptedException {
        // Acquire the semaphore
        semaphore.acquire();
        try {
            // Perform some critical operation
            System.out.println("Critical operation in controlled method.");
        } finally {
            // Release the semaphore, even if an exception occurred
            semaphore.release();
        }
    }

public static void main(String[] args) throws InterruptedException {
        SemaphoreExample example = new SemaphoreExample();
        new Thread(() -> {
            try {
                example.methodToControl();  // Acquires and releases the semaphore
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        })).start();

// Wait for thread to complete its action
        Thread.sleep(2000);  // Change this time duration as needed
    }
}
```
这两个示例展示了如何在Java并发编程中使用锁（Lock）和信号量（Semaphore）。