Java多线程实践：使用ExecutorService高效计算字符串相似度

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<String> 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<String> stringList;

        /**
         * 构造函数，传入当前需要比较的字符串和完整的字符串列表。
         * @param str 当前要计算相似度的字符串
         * @param stringList 用于比较的字符串列表
         */
        public SimilarityRunnable(String str, List<String> 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 方法在下面定义
}

// ... MultiThreadSimilarityCalculator 类中

    public static void main(String[] args) {
        // 创建一个固定大小的线程池，例如10个线程
        // 线程池会复用这些线程来执行提交的任务
        ExecutorService pool = Executors.newFixedThreadPool(10);

        // 获取待处理的字符串列表
        List<String> 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("所有相似度计算任务已提交。");
    }
}