1. 背景与挑战
在处理大量数据时，例如对一个包含数千甚至数万个字符串的列表进行两两相似度计算，单线程执行会非常耗时。将这类计算密集型任务并行化是提升性能的有效途径。然而，不恰当的多线程实现，如让每个线程独立地执行整个任务，不仅无法实现并行加速，反而可能引入额外的同步开销，甚至导致错误。正确的做法是将大任务分解为多个独立的小任务，然后由线程池中的线程并行处理。
2. 核心概念：ExecutorService与任务分解
Java提供了java.util.concurrent.ExecutorService接口及其实现，用于管理和执行异步任务。它提供了一种高级的并发机制，将任务提交与线程管理分离，使得开发者可以专注于业务逻辑，而不必直接操作底层线程。
任务分解原则： 要有效利用多线程，关键在于将原始问题分解成一系列可以独立执行的子任务。对于字符串相似度计算，我们可以将“计算一个特定字符串与列表中所有其他字符串的相似度”作为一个独立的任务。
3. 构建可执行任务：SimilarityRunnable
为了将每个字符串的相似度计算封装成一个可由线程执行的任务，我们创建一个实现Runnable接口的内部类SimilarityRunnable。
import java.util.List;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
// 假设 solution 对象和 listExe 已经定义并可用
// 例如：
class Solution {
public double findSimilarityRatio(String s1, String s2) {
// 实际的字符串相似度计算逻辑
// 这是一个示例，实际应用中会使用更复杂的算法
if (s1 == null || s2 == null) return 0.0;
int commonLength = 0;
for (char c : s1.toCharArray()) {
if (s2.indexOf(c) != -1) {
commonLength++;
}
}
return (double) commonLength / (s1.length() + s2.length() - commonLength);
}
}
class ListExecutor {
public List getStringList() {
// 模拟获取字符串列表
return List.of("apple", "apricot", "banana", "bandana", "orange", "grape");
}
}
public class MultiThreadSimilarityCalculator {
// 假设 solution 是一个线程安全的或在run方法内部进行同步的对象
private static final Solution solution = new Solution();
private static final ListExecutor listExe = new ListExecutor();
private static class SimilarityRunnable implements Runnable {
private final String str;
private final List stringList;
/**
* 构造函数，传入当前需要比较的字符串和完整的字符串列表。
* @param str 当前要计算相似度的字符串
* @param stringList 用于比较的字符串列表
*/
public SimilarityRunnable(String str, List stringList) {
this.str = str;
this.stringList = stringList;
}
@Override
public void run() {
for (String listStr : stringList) {
// 避免自身与自身比较。
// 注意：这里使用 == 比较的是对象引用，如果列表中包含通过不同方式创建但内容相同的字符串，
// 它们将不会被跳过。对于此场景，通常是希望跳过列表中的“同一个”元素。
if (listStr == str) {
continue;
}
// 打印当前线程名和相似度结果
// 如果 solution 对象非线程安全，则需要在这里对其进行同步，例如：
// synchronized (solution) { ... }
System.out.println(Thread.currentThread().getName()
+ ": similarity of '" + str + "' to '" + listStr + "' is "
+ solution.findSimilarityRatio(str, listStr));
}
}
}
// ... main 方法在下面定义
} 在SimilarityRunnable中：
- str：表示当前需要进行比较的基准字符串。
- stringList：表示需要与str进行比较的完整字符串列表。
- run()方法：遍历stringList，对每个元素调用solution.findSimilarityRatio()方法计算相似度。
- if (listStr == str)：这是一个重要的优化，用于跳过字符串与自身的比较。这里使用==比较的是对象引用，确保同一个列表元素不会与自身比较。如果希望跳过内容相同的字符串（即使它们是不同的对象），则需要使用str.equals(listStr)。
4. 任务调度与执行：ExecutorService
在main方法中，我们创建ExecutorService，并向其提交SimilarityRunnable任务。
立即学习“Java免费学习笔记（深入）”；
// ... MultiThreadSimilarityCalculator 类中
public static void main(String[] args) {
// 创建一个固定大小的线程池，例如10个线程
// 线程池会复用这些线程来执行提交的任务
ExecutorService pool = Executors.newFixedThreadPool(10);
// 获取待处理的字符串列表
List stringList = listExe.getStringList();
// 遍历字符串列表，为每个字符串创建一个 SimilarityRunnable 任务并提交给线程池
for (String str : stringList) {
pool.submit(new SimilarityRunnable(str, stringList));
}
// 所有任务提交完毕后，关闭线程池
// shutdown() 方法会等待所有已提交的任务执行完毕，然后关闭线程池
pool.shutdown();
// （可选）等待所有任务完成，以确保主线程在所有计算完成前不会退出
// try {
// pool.awaitTermination(Long.MAX_VALUE, TimeUnit.NANOSECONDS);
// } catch (InterruptedException e) {
// Thread.currentThread().interrupt();
// System.err.println("等待线程池终止时被中断: " + e.getMessage());
// }
System.out.println("所有相似度计算任务已提交。");
}
} 在main方法中：
- Executors.newFixedThreadPool(10)：创建了一个包含10个线程的线程池。这意味着最多有10个SimilarityRunnable任务可以同时执行。
- for (String str : stringList)：循环遍历原始字符串列表。
- pool.submit(new SimilarityRunnable(str, stringList))：为列表中的每个字符串创建一个SimilarityRunnable实例，并将其提交给线程池。线程池会负责调度这些任务，使用其内部的线程来执行run()方法。
- pool.shutdown()：这是一个非常关键的步骤。它会启动线程池的关闭序列，不再接受新的任务，但会等待所有已提交的任务执行完毕。如果忘记调用此方法，程序可能无法正常退出，因为线程池中的线程会一直保持活跃状态。
5. 注意事项与最佳实践
-
线程安全性：
- solution.findSimilarityRatio()方法本身必须是线程安全的。如果它在内部修改共享状态，或者使用了非线程安全的辅助类，那么在调用它之前需要进行适当的同步（例如，使用synchronized关键字或ReentrantLock）。
- 本例中的Solution类是一个简单的示例，如果findSimilarityRatio方法是纯函数（不修改任何外部状态），那么它是线程安全的。
-
任务粒度：
- 将任务分解得过小会导致过多的任务提交和调度开销。
- 将任务分解得过大则可能无法充分利用多核资源。
- 本例中，将“一个字符串与所有其他字符串比较”作为任务粒度通常是合适的。
-
线程池大小：
- Executors.newFixedThreadPool(int nThreads)中的nThreads通常设置为CPU核心数（Runtime.getRuntime().availableProcessors()）或略大于核心数，以平衡计算和I/O等待。
- 对于计算密集型任务，通常设置为CPU核心数。
-
资源管理：
- 务必在所有任务提交后调用pool.shutdown()来关闭线程池。
- 如果需要等待所有任务完成才能继续主线程的执行，可以使用pool.awaitTermination()方法。
-
异常处理：
- 在run()方法内部，应该包含健壮的异常处理逻辑，以防止单个任务的失败导致整个程序崩溃。
通过上述方法，我们能够有效地利用Java的ExecutorService和线程池机制，将复杂的字符串相似度计算任务并行化，从而显著提高程序的执行效率。
