Java并发编程：线程池、信号量等工具的应用实例

原创た入场券 2024-09-15 07:57 73阅读 0赞

在Java并发编程中，线程池、信号量等工具是高效管理和控制线程的重要手段。以下是这些工具的一些应用实例：

1. **线程池**：
   - 应用场景：重复执行的任务，避免频繁创建和销毁线程。
   - 实例：使用ThreadPoolExecutor来批量创建线程执行任务。

```java
import java.util.concurrent.*;

public class ThreadPoolExample {
    public static void main(String[] args) {
        // 创建线程池
        ExecutorService executor = Executors.newFixedThreadPool(10);

// 提交任务到线程池
        for (int i = 0; i < 50; i++) {
            Runnable task = () -> System.out.println("Task " + i);
            executor.execute(task);
        }

// 关闭线程池，释放资源
        executor.shutdown();
        while (!executor.isTerminated()) {
            // 等待所有任务完成或者线程池关闭
        }
    }
}
```

2. **信号量**：
   - 应用场景：控制共享资源的访问，如限制同时连接的数量。
   - 实例：使用Semaphore来控制多个线程对同一资源的访问。

```java
import java.util.concurrent.*;

public class SemaphoreExample {
    public static void main(String[] args) {
        // 创建信号量，初始值为1
        Semaphore semaphore = new Semaphore(1);

// 创建两个任务线程
        Thread thread1 = new Thread(() -> {
            try {
                // 获取信号量，如果当前值大于0，允许一次访问
                semaphore.acquire();
                System.out.println("Thread 1 accessed the resource.");
            } catch (InterruptedException e) {
                e.printStackTrace();
            } finally {
                // 访问完成后，释放信号量
                semaphore.release();
            }
        }));

Thread thread2 = new Thread(() -> {
            try {
                // 获取信号量，如果当前值大于0，允许一次访问
                semaphore.acquire();
                System.out.println("Thread 2 accessed the resource.");
            } catch (InterruptedException e) {
                e.printStackTrace();
            } finally {
                // 访问完成后，释放信号量
                semaphore.release();
            }
        }));

// 启动线程
        thread1.start();
        thread2.start();

// 等待所有线程完成任务
        thread1.join();
        thread2.join();
    }
}
```

以上就是Java并发编程中线程池和信号量的应用实例。