本文针对Java并发编程中常见的set<int, Future<Integer>> is not applicable to arguments (int,int)错误，深入剖析了其产生的原因，即试图将整型值直接赋值给存储Future<Integer>对象的集合。文章将详细阐述Future对象的特性，并提供正确的解决方案，包括如何初始化数据、避免并发问题，以及合理使用ExecutorService。
在Java并发编程中，Future接口代表异步计算的结果。当使用ExecutorService提交任务时，会返回一个Future对象，该对象允许你检查任务是否完成、获取任务结果（如果已完成）以及取消任务。然而，不恰当的使用Future会导致编译错误或运行时异常。本文将针对一个常见的错误场景进行分析，并提供解决方案。
问题分析：set<int, Future<Integer>> is not applicable to arguments (int,int)
这个错误通常发生在尝试将一个整数值直接赋值给一个存储Future<Integer>对象的集合时。Future对象本身并不是一个简单的数值，它代表一个尚未完成的计算结果的承诺。因此，直接将整数赋值给Future类型的变量或集合元素是不允许的。
此外，Future对象一旦创建，其内部状态（包括最终的结果）是不可变的。这意味着你不能通过set方法直接修改Future对象中存储的值。
解决方案
解决这个问题的关键在于理解Future对象的本质，以及如何正确地处理异步计算的结果。
1. 数据初始化：直接使用整数集合
如果你的目标是维护一个整数集合，并在多线程环境下对其进行操作，那么直接使用List<Integer>或其他合适的整数集合是更合适的选择，而不是使用List<Future<Integer>>。
import java.util.ArrayList; import java.util.List; import java.util.concurrent.ThreadLocalRandom; import java.util.concurrent.Executors; import java.util.concurrent.ExecutorService; public class ConcurrencyExample { public static void main(String[] args) throws InterruptedException { ExecutorService ex = Executors.newFixedThreadPool(10); List<Integer> elements = new ArrayList<>(); for (int i = 0; i < 100; i++) { elements.add(1000); } int sum = 0; for (int el : elements) { sum += el; } System.out.println("Initial sum: " + sum); for (int i = 0; i < 10_000; i++) { ex.submit(() -> { int firstIndex = ThreadLocalRandom.current().nextInt(100); int secondIndex = ThreadLocalRandom.current().nextInt(100); int randomAmount = ThreadLocalRandom.current().nextInt(1000); synchronized (elements) { // Correctly synchronize access to the list if (elements.get(firstIndex) - randomAmount >= 0) { elements.set(firstIndex, elements.get(firstIndex) - randomAmount); } } }); } ex.shutdown(); ex.awaitTermination(60, java.util.concurrent.TimeUnit.SECONDS); int finalSum = 0; for (int el : elements) { finalSum += el; } System.out.println("Final sum: " + finalSum); } }
2. 并发问题：线程安全
当多个线程同时访问和修改共享数据时，需要考虑线程安全问题。在上面的代码中，多个线程可能会同时尝试修改elements列表中的元素，这可能导致数据不一致。为了解决这个问题，可以使用synchronized关键字来保证对elements列表的互斥访问。
3. ExecutorService的正确使用
ex.shutdown() 会阻止 ExecutorService 接受新的任务，但不会中断正在执行的任务。为了确保所有任务都完成后再进行后续操作，可以使用 ex.awaitTermination() 方法等待所有任务完成。
4. 使用原子类
如果需要更高效的并发控制，可以考虑使用java.util.concurrent.atomic包中的原子类，例如AtomicInteger。原子类提供了原子操作，可以保证在多线程环境下对单个变量的读写操作是原子性的，避免了使用synchronized关键字带来的性能开销。
import java.util.ArrayList; import java.util.List; import java.util.concurrent.ThreadLocalRandom; import java.util.concurrent.Executors; import java.util.concurrent.ExecutorService; import java.util.concurrent.atomic.AtomicInteger; public class ConcurrencyExampleAtomic { public static void main(String[] args) throws InterruptedException { ExecutorService ex = Executors.newFixedThreadPool(10); List<AtomicInteger> elements = new ArrayList<>(); for (int i = 0; i < 100; i++) { elements.add(new AtomicInteger(1000)); } int sum = 0; for (AtomicInteger el : elements) { sum += el.get(); } System.out.println("Initial sum: " + sum); for (int i = 0; i < 10_000; i++) { ex.submit(() -> { int firstIndex = ThreadLocalRandom.current().nextInt(100); int secondIndex = ThreadLocalRandom.current().nextInt(100); int randomAmount = ThreadLocalRandom.current().nextInt(1000); AtomicInteger firstElement = elements.get(firstIndex); int currentValue = firstElement.get(); while (currentValue - randomAmount >= 0) { if (firstElement.compareAndSet(currentValue, currentValue - randomAmount)) { break; } else { currentValue = firstElement.get(); // Refresh the current value } } }); } ex.shutdown(); ex.awaitTermination(60, java.util.concurrent.TimeUnit.SECONDS); int finalSum = 0; for (AtomicInteger el : elements) { finalSum += el.get(); } System.out.println("Final sum: " + finalSum); } }
在这个版本中，elements列表存储的是AtomicInteger对象。使用compareAndSet方法可以原子性地更新AtomicInteger的值，避免了并发问题。注意，compareAndSet方法需要在循环中调用，以处理并发更新失败的情况。
总结
理解Future对象的本质和正确使用并发工具是编写高效、可靠的并发程序的关键。当遇到类似set<int, Future<Integer>> is not applicable to arguments (int,int)的错误时，首先要检查数据类型是否匹配，并考虑线程安全问题。选择合适的数据结构和并发控制机制，可以有效地解决并发编程中的各种问题。
评论（已关闭）
评论已关闭