使用ExecutorService高效并行计算字符串相似度

在处理大量数据时，例如计算一个字符串列表内所有字符串两两之间的相似度，如果采用单线程顺序执行，效率会非常低下。而如果采用多线程，但任务分解不合理或同步机制使用不当，也可能无法达到预期的并行效果，甚至引入新的问题。本教程将指导您如何使用java的executorservice，以一种标准且高效的方式实现这一目标。

问题分析与传统方法局限

在原始场景中，用户尝试通过创建一个Runnable实例，并在其中使用synchronized (LOCK)来同步对整个列表的相似度计算过程。这种做法存在以下几个问题：

1. 不合理的同步范围： synchronized (LOCK)锁住了整个run方法中的循环，导致同一时刻只有一个线程能够执行相似度计算，这完全失去了多线程并行的意义。
2. 任务分解不当： 每个线程被设计为独立完成整个列表的相似度计算，这不仅重复工作，而且在同步的限制下，实际上是串行执行。
3. 索引越界风险： newList.get(i)和i++的组合在循环中可能导致索引越界（i可能达到newList.size()），且逻辑上可能不是期望的两两比较。

正确的做法是将大任务分解成多个小任务，每个小任务独立完成一部分工作，然后由线程池来调度这些小任务的并行执行。

使用ExecutorService进行任务分解与并行计算

Java的java.util.concurrent.ExecutorService提供了一种高级的并发API，用于管理线程池和提交任务。通过它，我们可以将计算字符串相似度的任务分解为针对每个字符串的独立子任务，然后由线程池中的线程并行执行。

核心思想

1. 创建线程池： 使用Executors.newFixedThreadPool(int nThreads)创建一个固定大小的线程池，限制同时运行的线程数量。
2. 任务封装： 将每个字符串的相似度计算逻辑封装到一个Runnable实现中。这个Runnable负责计算一个特定字符串与列表中所有其他字符串的相似度。
3. 提交任务： 遍历字符串列表，为每个字符串创建一个Runnable实例，并将其提交给ExecutorService。
4. 关闭线程池： 在所有任务提交完毕后，调用pool.shutdown()优雅地关闭线程池，等待所有已提交任务完成。

示例代码与解析

以下是使用ExecutorService实现字符串相似度并行计算的示例代码：

算家云

高效、便捷的人工智能算力服务平台

37

查看详情

import java.util.ArrayList;
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) {
        // 模拟耗时的相似度计算
        try {
            Thread.sleep(10); // 模拟计算耗时
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }
        // 实际的相似度计算逻辑
        return (double) Math.min(s1.length(), s2.length()) / Math.max(s1.length(), s2.length());
    }
}

// 假设listExe提供获取字符串列表的方法
class ListExecutor {
    public List<String> getStringList() {
        List<String> list = new ArrayList<>();
        list.add("apple");
        list.add("apricot");
        list.add("banana");
        list.add("bandana");
        list.add("orange");
        list.add("grape");
        return list;
    }
}

public class MultiThreadSimilarityCalculator {

    // solution对象，假设它是线程安全的或我们会在需要时同步
    private static final Solution solution = new Solution();
    private static final ListExecutor listExe = new ListExecutor();

    public static void main(String[] args) {
        // 创建一个固定大小为10的线程池
        ExecutorService pool = Executors.newFixedThreadPool(10);
        List<String> stringList = listExe.getStringList();

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

        // 所有任务提交完毕后，关闭线程池。
        // shutdown()方法会阻止新的任务提交，并等待所有已提交任务完成。
        pool.shutdown();
        System.out.println("所有任务已提交，线程池正在关闭...");
    }

    /**
     * SimilarityRunnable 类封装了计算一个字符串与列表中所有其他字符串相似度的任务。
     */
    private static class SimilarityRunnable implements Runnable {
        private final String str; // 当前要比较的字符串
        private final List<String> stringList; // 整个字符串列表

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

        @Override
        public void run() {
            for (String listStr : stringList) {
                // 避免自身与自身比较，这里使用 == 判断引用是否相同，
                // 如果字符串内容相同但引用不同，仍会比较。
                // 如果需要严格避免内容相同的字符串比较，需要使用 equals()。
                if (listStr == str) {
                    continue;
                }

                // 如果 solution 对象不是线程安全的，需要在这里进行同步。
                // 例如：synchronized (solution) { ... }
                System.out.println(Thread.currentThread().getName()
                    + ": 字符串 '" + str + "' 与 '" + listStr + "' 的相似度是 "
                    + solution.findSimilarityRatio(str, listStr));
            }
        }
    }
}

代码解析：

1. main 方法：

   • ExecutorService pool = Executors.newFixedThreadPool(10);：创建了一个包含10个线程的线程池。这意味着最多可以有10个任务同时执行。
   • for (String str : stringList)：迭代原始字符串列表。
   • pool.submit(new SimilarityRunnable(str, stringList));：对于列表中的每一个字符串str，都创建一个SimilarityRunnable实例，并将其提交给线程池。每个SimilarityRunnable实例都负责计算str与stringList中所有其他字符串的相似度。
   • pool.shutdown();：在所有任务都提交给线程池后，调用shutdown()方法。这会阻止新的任务被提交，并允许线程池中的线程完成所有已提交的任务，然后优雅地终止。

2. SimilarityRunnable 类：

   • 它实现了Runnable接口，定义了任务的执行逻辑。
   • 构造函数接收一个str（当前要进行比较的字符串）和stringList（完整的字符串列表）。
   • run() 方法包含实际的业务逻辑：遍历stringList，计算str与listStr的相似度。
   • if (listStr == str)：这是一个优化点，用于跳过字符串自身与自身的比较。需要注意的是，==比较的是对象的引用，如果列表中存在内容相同但引用不同的字符串，它们仍然会被比较。如果希望完全跳过内容相同的字符串，应使用listStr.equals(str)。
   • 线程安全考虑： solution.findSimilarityRatio(str, listStr)这行代码假设solution对象及其findSimilarityRatio方法是线程安全的（即，它不会修改共享状态，或者其内部已处理了并发）。如果solution对象不是线程安全的，那么在调用其方法时需要进行额外的同步，例如 synchronized (solution) { ... }。

注意事项与最佳实践

1. 线程池大小： newFixedThreadPool(10)中的10是一个示例值。理想的线程池大小取决于您的任务性质（CPU密集型或I/O密集型）、系统可用核心数以及内存限制。对于CPU密集型任务，通常设置为CPU核心数加1或2。
2. 共享资源同步： 确保所有线程访问的共享资源（如本例中的solution对象）是线程安全的。如果不是，必须采取适当的同步措施（如synchronized关键字、ReentrantLock等）。
3. 任务粒度： 将任务分解为粒度适中的小任务非常重要。过大的任务会减少并行度，过小的任务则会增加线程调度的开销。本例中，为每个字符串创建一个任务是合理的粒度。
4. 异常处理： 在Runnable的run()方法中，应该包含健壮的异常处理逻辑，以防止单个任务的失败影响整个应用程序。
5. 线程池的关闭： 务必在应用程序生命周期结束时调用pool.shutdown()。如果需要等待所有任务完成，可以使用pool.awaitTermination()方法。例如：

   pool.shutdown();
   try {
       if (!pool.awaitTermination(60, TimeUnit.SECONDS)) { // 等待最多60秒
           pool.shutdownNow(); // 如果超时，强制关闭
       }
   } catch (InterruptedException ex) {
       pool.shutdownNow();
       Thread.currentThread().interrupt();
   }

   登录后复制
6. submit() vs execute()： ExecutorService提供了execute()和submit()方法。
   • execute(Runnable command)：用于提交Runnable任务，不返回任何结果。
   • submit(Runnable task) 或 submit(Callable<T> task)：提交Runnable或Callable任务，返回一个Future对象，可以用来检查任务状态、获取任务结果或取消任务。在本例中，我们不需要获取任务的返回值，所以submit(Runnable)或execute(Runnable)都可以。

总结

通过本教程，我们学习了如何利用Java的ExecutorService和线程池机制，将字符串相似度计算任务分解为可并行执行的子任务。这种模式不仅能够有效利用多核处理器的性能，提高应用程序的响应速度和吞吐量，而且通过线程池的管理，避免了手动创建和销毁线程的开销，使并发编程更加简洁和高效。理解并正确应用这种任务分解和线程池管理模式，是进行高效并发编程的关键。

以上就是使用ExecutorService高效并行计算字符串相似度的详细内容，更多请关注php中文网其它相关文章！