Java并发工具类理解和运用实例

原创我就是我 2024-12-05 01:48 19阅读 0赞

Java并发工具类是Java语言中用来处理多线程并发问题的集合。主要包括以下几类：

1. `java.util.concurrent`（主线程库）：
   - `ExecutorService`：线程池，管理一组线程。
   - `Thread`：基础线程类型。
   - `Future`：表示异步操作的完成和结果。
   
2. `java.util.concurrent.locks`（锁工具类）：
   - `ReentrantLock`：可重入锁，提供原子操作。
   
3. `java.util.concurrent.atomic`（原子工具类）：
   - 原子操作类，如`AtomicInteger`, `AtomicLong`, 等，它们提供了基本的原子操作。

运用实例：

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

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

// 提交任务到线程池
        for (int i = 0; i < 10; i++) {
            final int taskIndex = i;
            executor.submit(() -> {
                System.out.println("Task " + taskIndex + " executed by thread: " + Thread.currentThread().getName());
                // 模拟耗时操作
                try {
                    Thread.sleep(500);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }));
        }

// 关闭线程池，释放资源
        executor.shutdown();

// 确保所有任务完成后再打印信息
        while (!executor.isTerminated())) {
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}
```

2. 锁工具类例子：
```java
import java.util.concurrent.locks.ReentrantLock;

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

public void safeMethod() {
        // 使用锁保护代码块，确保同一时间只有一个线程执行这段代码
        lock.lock();
        try {
            System.out.println("Executing critical section...");
            // 模拟耗时操作
            Thread.sleep(1000);
        } finally {
            // 无论是否发生异常，都要解锁
            lock.unlock();
        }
    }

public static void main(String[] args) {
        LockExample example = new LockExample();
        example.safeMethod();
    }
}
```

以上例子展示了Java并发工具类如何应用于多线程环境中的任务管理和同步。