ExecutorService 多线程

在Java中，利用线程池（如`ExecutorService`）来执行循环任务可以显著提高程序的并发性能。下面是一个简单的示例，展示了如何使用线程池来执行一个for循环中的任务。

首先，你需要导入必要的Java并发包：

```java
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;
```

然后，你可以创建一个线程池并提交任务给它。在这个例子中，我们将创建一个固定大小的线程池，并提交一系列打印任务给线程池执行。

```java
public class ThreadPoolDemo {
    public static void main(String[] args) {
        // 创建一个固定大小的线程池，这里设置为4个线程
        ExecutorService executorService = Executors.newFixedThreadPool(4);

        // 提交任务给线程池执行
        for (int i = 0; i < 10; i++) {
            // 使用lambda表达式创建Runnable任务
            Runnable task = () -> {
                // 模拟任务执行，这里只是简单地打印任务编号和当前线程名
                System.out.println("Executing task " + i + " by " + Thread.currentThread().getName());
                try {
                    // 模拟任务耗时
                    TimeUnit.SECONDS.sleep(1);
                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt();
                    System.err.println("Task " + i + " was interrupted.");
                }
            };

            // 注意：由于lambda表达式中的变量i是final或effectively final的，
            // 所以这里的i在任务执行时会是循环结束时的值（对于最后一个任务来说是10），
            // 而不是我们期望的循环中的值（0到9）。
            // 为了解决这个问题，我们可以使用闭包或创建一个新的变量来捕获每次循环的值。

            // 修正：使用final的局部变量来捕获每次循环的值
            final int taskIndex = i;
            Runnable correctedTask = () -> {
                System.out.println("Executing corrected task " + taskIndex + " by " + Thread.currentThread().getName());
                try {
                    TimeUnit.SECONDS.sleep(1);
                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt();
                    System.err.println("Corrected task " + taskIndex + " was interrupted.");
                }
            };

            // 提交任务到线程池
            executorService.submit(correctedTask);
        }

        // 关闭线程池（这里使用shutdown而不是shutdownNow，因为我们希望等待所有任务完成）
        // 注意：调用shutdown()后，线程池将不再接受新任务，但会继续执行已提交的任务。
        executorService.shutdown();

        try {
            // 等待所有任务完成或超时（这里设置为等待一段时间，确保所有任务有足够的时间完成）
            // 注意：在实际应用中，你可能需要根据实际情况调整等待时间或处理超时情况。
            if (!executorService.awaitTermination(60, TimeUnit.SECONDS)) {
                // 超时处理（可选）：如果等待超时，可以强制关闭线程池并处理未完成的任务。
                executorService.shutdownNow();
                System.err.println("Executor service did not terminate in time, forcing shutdown.");
            }
        } catch (InterruptedException e) {
            // 当前线程在等待过程中被中断（可选）：记录中断状态并处理。
            executorService.shutdownNow();
            Thread.currentThread().interrupt();
            System.err.println("Executor service shutdown interrupted.");
        }

        System.out.println("All tasks completed.");
    }
}
```

在这个例子中，我们注意到了一个关于lambda表达式和循环变量的问题。由于lambda表达式在Java中是“捕获”变量的值，而不是按值传递，因此当循环结束时，变量`i`的值将是10（循环的终止条件）。为了解决这个问题，我们在循环内部创建了一个`final`的局部变量`taskIndex`来捕获每次循环的值，并将其用于lambda表达式中。

此外，我们还展示了如何正确地关闭线程池并等待所有任务完成。在实际应用中，你可能需要根据实际情况调整等待时间或处理超时情况。