我整理的一些关于【Java】的项目学习资料（附讲解～～）和大家一起分享、学习一下：

 https://d.51cto.com/bLN8S1

Java 中的 computeIfAbsent 方法和超时机制

在 Java 中，computeIfAbsent 是一个非常有用的函数，通常被用于 Map 接口，特别是 ConcurrentHashMap。它的作用是，如果指定的键不存在，则计算一个值并将其放入映射中。在高并发的场景中，这个方法能够有效减少锁竞争，提高性能。然而，默认的 computeIfAbsent 方法没有超时机制，即它会一直等到计算结果产生为止。在某些情况下，我们可能需要为这个过程设置一个超时限制，避免在高负载或长时间运行的操作中造成阻塞。

computeIfAbsent 的基本用法

computeIfAbsent 方法接收一个键和一个计算器（或者生成值的函数），在该键不存在于 Map 中时调用该计算器。下面是一个简单的代码示例：

import java.util.concurrent.ConcurrentHashMap;

public class ComputeIfAbsentExample {
    public static void main(String[] args) {
        ConcurrentHashMap<String, String> map = new ConcurrentHashMap<>();

        map.computeIfAbsent("key1", key -> {
            // 模拟耗时操作
            try {
                Thread.sleep(1000); // 1秒
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
            return "value1";
        });

        System.out.println(map.get("key1"));
    }
}
  • 1.
  • 2.
  • 3.
  • 4.
  • 5.
  • 6.
  • 7.
  • 8.
  • 9.
  • 10.
  • 11.
  • 12.
  • 13.
  • 14.
  • 15.
  • 16.
  • 17.
  • 18.
  • 19.

上述代码中，当调用 computeIfAbsent 方法时，如果 map 中不存在 key1，则会执行对应的计算器，添加 value1。

添加超时机制的解决方案

在实际的应用中，有时候我们需要在计算过程中设置一个超时时间。例如，如果某个计算过程超过了预设的时间限制，我们希望能够抛出异常或返回一个默认值。虽然 computeIfAbsent 本身并不支持超时机制，但我们可以通过引入 CompletableFuture 来实现。

下面是一个如何实现带有超时机制的代码示例：

import java.util.concurrent.*;

public class ComputeIfAbsentWithTimeout {
    private static final ConcurrentHashMap<String, String> map = new ConcurrentHashMap<>();
    
    public static void main(String[] args) {
        try {
            String value = computeIfAbsentWithTimeout("key2", 500, key -> {
                // 模拟超时操作
                try {
                    Thread.sleep(1000); // 1秒
                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt();
                }
                return "value2";
            });
            System.out.println(value);
        } catch (TimeoutException e) {
            System.out.println("计算超时: " + e.getMessage());
        }
    }

    public static String computeIfAbsentWithTimeout(String key, long timeout, Function<String, String> mappingFunction) throws TimeoutException {
        return map.computeIfAbsent(key, k -> {
            CompletableFuture<String> future = CompletableFuture.supplyAsync(() -> mappingFunction.apply(k));
            try {
                return future.get(timeout, TimeUnit.MILLISECONDS);
            } catch (TimeoutException e) {
                future.cancel(true); // 取消计算
                throw new TimeoutException("操作超时");
            } catch (Exception e) {
                throw new RuntimeException(e);
            }
        });
    }
}
  • 1.
  • 2.
  • 3.
  • 4.
  • 5.
  • 6.
  • 7.
  • 8.
  • 9.
  • 10.
  • 11.
  • 12.
  • 13.
  • 14.
  • 15.
  • 16.
  • 17.
  • 18.
  • 19.
  • 20.
  • 21.
  • 22.
  • 23.
  • 24.
  • 25.
  • 26.
  • 27.
  • 28.
  • 29.
  • 30.
  • 31.
  • 32.
  • 33.
  • 34.
  • 35.
  • 36.

在这个例子中，我们定义了 computeIfAbsentWithTimeout 方法，利用 CompletableFuture 执行异步操作，并设置超时。超过这个时间限制，抛出一个 TimeoutException。

状态图

状态图可以帮助我们更好地理解方法的执行流程，看看在超时与正常执行之间的转变。以下是状态图的示例：

超过500毫秒 正常返回结果 提交任务 等待结果 超时 完成 任务取消

ER图

我们还可以用 ER 图来表示数据流关系，帮助我们更好地理解 Map 的数据存储和计算的关系。

Map string key string value Function string key function mappingFunction 使用

结论

通过 computeIfAbsent 方法，我们可以轻松地在 Map 中处理缺失的值，而带有超时机制的实现往往是需要针对具体业务场景自定义的。在多线程环境中，使用 CompletableFuture 与超时组合，可以有效防止长时间的无响应。希望本文能帮助你更好地理解 Java 中的 computeIfAbsent 方法及其扩展用法。

整理的一些关于【Java】的项目学习资料（附讲解～～），需要自取：

 https://d.51cto.com/bLN8S1