Java并发编程：线程池、Lock和Semaphore示例

原创太过爱你忘了你带给我的痛 2025-03-19 09:09 14阅读 0赞

在Java的并发编程中，线程池、Lock和Semaphore都是非常重要的概念。下面分别给出这几种示例：

1. 线程池：
```java
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class ThreadPoolExample {
    public static void main(String[] args) {
        // 创建一个固定大小的线程池
        ExecutorService executor = Executors.newFixedThreadPool(5);

// 提交任务到线程池
        for (int i = 0; i < 10; i++) {
            Runnable task = () -> {
                System.out.println("Task " + i + " executed by thread: " + Thread.currentThread().getName());
            };
            executor.execute(task);
        }

// 关闭线程池，释放资源
        executor.shutdown();
    }
}
```
2. 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 acquireLock() throws InterruptedException {
        // 获取锁，如果当前线程没有获得过此锁，则会阻塞
        lock.acquire();
        System.out.println("Acquired lock: " + Thread.currentThread().getName());
    }

public void releaseLock() {
        // 释放锁，即使当前线程没有获得过此锁也不会报错
        lock.release();
        System.out.println("Released lock: " + Thread.currentThread().getName());
    }
}
```
3. Semaphore（信号量）：
```java
import java.util.concurrent.Semaphore;

public class SemaphoreExample {
    private final Semaphore semaphore = new Semaphore(5);

public void acquireSemaphore() throws InterruptedException {
        // 获取信号量，如果当前线程没有获得过此信号量且信号量的容量大于0，则会阻塞
        semaphore.acquire();
        System.out.println("Acquired semaphore: " + Thread.currentThread().getName());
    }

public void releaseSemaphore() {
        // 释放信号量，即使当前线程没有获得过此信号量也不会报错
        semaphore.release();
        System.out.println("Released semaphore: " + Thread.currentThread().getName());
    }
}
```
以上示例展示了Java并发编程中常用的线程池（ThreadPool）、锁（Lock）和信号量（Semaphore）。