当前位置：首页 > 文章列表 > 文章 > java教程 > Future对象常见错误与优化技巧

Future对象常见错误与优化技巧

2025-09-01 13:51:42 0浏览收藏

目前golang学习网上已经有很多关于文章的文章了，自己在初次阅读这些文章中，也见识到了很多学习思路；那么本文《Future对象使用误区与优化方案》，也希望能帮助到大家，如果阅读完后真的对你学习文章有帮助，欢迎动动手指，评论留言并分享~

并发编程中Future对象使用不当及解决方案

本文针对Java并发编程中常见的set> is not applicable to arguments (int,int)错误，深入剖析了其产生的原因，即试图将整型值直接赋值给存储Future对象的集合。文章将详细阐述Future对象的特性，并提供正确的解决方案，包括如何初始化数据、避免并发问题，以及合理使用ExecutorService。

在Java并发编程中，Future接口代表异步计算的结果。当使用ExecutorService提交任务时，会返回一个Future对象，该对象允许你检查任务是否完成、获取任务结果（如果已完成）以及取消任务。然而，不恰当的使用Future会导致编译错误或运行时异常。本文将针对一个常见的错误场景进行分析，并提供解决方案。

问题分析：set> is not applicable to arguments (int,int)

这个错误通常发生在尝试将一个整数值直接赋值给一个存储Future对象的集合时。Future对象本身并不是一个简单的数值，它代表一个尚未完成的计算结果的承诺。因此，直接将整数赋值给Future类型的变量或集合元素是不允许的。

此外，Future对象一旦创建，其内部状态（包括最终的结果）是不可变的。这意味着你不能通过set方法直接修改Future对象中存储的值。

解决方案

解决这个问题的关键在于理解Future对象的本质，以及如何正确地处理异步计算的结果。

1. 数据初始化：直接使用整数集合

如果你的目标是维护一个整数集合，并在多线程环境下对其进行操作，那么直接使用List或其他合适的整数集合是更合适的选择，而不是使用List>。

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> is not applicable to arguments (int,int)的错误时，首先要检查数据类型是否匹配，并考虑线程安全问题。选择合适的数据结构和并发控制机制，可以有效地解决并发编程中的各种问题。

到这里，我们也就讲完了《Future对象常见错误与优化技巧》的内容了。个人认为，基础知识的学习和巩固，是为了更好的将其运用到项目中，欢迎关注golang学习网公众号，带你了解更多关于的知识点！