Java多线程优化：高效计算字符串相似度

import java.util.List;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

// 假设 solution 对象包含 findSimilarityRatio 方法
// 并且是线程安全的，或者在必要时进行同步
class Solution {
    public double findSimilarityRatio(String s1, String s2) {
        // 实际的字符串相似度计算逻辑
        // 这里只是一个模拟，例如使用Jaro-Winkler、Levenshtein等算法
        return (s1.length() + s2.length()) / 2.0; // 示例模拟
    }
}

public class SimilarityCalculator {

    // 假设 solution 是一个全局或静态可访问的实例
    private static final Solution solution = new Solution();

    /**
     * 定义一个任务，用于计算单个字符串与列表中所有其他字符串的相似度。
     */
    private static class SimilarityRunnable implements Runnable {
        private final String targetStr; // 需要比较的字符串
        private final List<String> stringList; // 整个字符串列表

        public SimilarityRunnable(String targetStr, List<String> stringList) {
            this.targetStr = targetStr;
            this.stringList = stringList;
        }

        @Override
        public void run() {
            for (String listStr : stringList) {
                // 避免自身与自身比较，通常相似度为1
                // 注意：这里使用 == 比较的是引用，如果字符串是通过值相等但引用不同的方式创建，
                // 则需要使用 .equals()。根据具体需求选择。
                if (listStr == targetStr) {
                    continue;
                }

                // 如果 solution.findSimilarityRatio 方法不是线程安全的，
                // 则需要在调用前进行同步，例如：
                // synchronized (solution) {
                //     System.out.println(... solution.findSimilarityRatio(targetStr, listStr));
                // }
                // 但通常相似度计算函数应该是纯函数，不涉及共享状态，因此通常无需同步。
                double similarity = solution.findSimilarityRatio(targetStr, listStr);
                System.out.println(Thread.currentThread().getName()
                    + ": 字符串 '" + targetStr + "' 与 '" + listStr + "' 的相似度是 "
                    + String.format("%.2f", similarity));
            }
        }
    }

    // 模拟获取字符串列表的方法
    static class ListExecutor {
        public static List<String> getStringList() {
            return List.of("apple", "aple", "apply", "banana", "bandana", "orange");
        }
    }

    public static void main(String[] args) {
        // 1. 创建一个固定大小的线程池，例如10个线程
        ExecutorService pool = Executors.newFixedThreadPool(10);

        // 2. 获取待处理的字符串列表
        List<String> stringList = ListExecutor.getStringList();

        // 3. 为列表中的每个字符串创建一个 SimilarityRunnable 任务并提交给线程池
        for (String str : stringList) {
            pool.submit(new SimilarityRunnable(str, stringList));
        }

        // 4. 关闭线程池：在所有任务提交完毕后，通知线程池不再接受新任务，并等待已提交任务完成
        pool.shutdown();

        // 可选：等待所有任务执行完毕，否则主线程可能在任务完成前退出
        // try {
        //     pool.awaitTermination(Long.MAX_VALUE, TimeUnit.NANOSECONDS);
        // } catch (InterruptedException e) {
        //     Thread.currentThread().interrupt();
        //     System.err.println("等待线程池终止时被中断: " + e.getMessage());
        // }
        System.out.println("所有相似度计算任务已提交。");
    }
}