接口Computable的使用方法

接口`Computable`是一个泛型接口，它有一个泛型类型参数`A`表示输入类型，有一个泛型类型参数`V`表示输出类型。该接口有一个`compute`方法，用于接收输入参数并返回输出值。

以下是一个示例代码：

public interface Computable<A, V> {
    V compute(A arg) throws InterruptedException;
}

该接口表示一个计算器，接收一个输入参数`arg`，返回一个结果值`V`。具体的计算逻辑由实现该接口的类来实现。

以下是一个实现了`Computable`接口的类的示例代码：

public class ExpensiveFunction implements Computable<String, BigInteger> {
    public BigInteger compute(String arg) throws InterruptedException {
        // 计算逻辑
        return new BigInteger(arg);
    }
}

该类实现了`Computable`接口，接收一个字符串类型的参数并返回一个`BigInteger`类型的结果值。

以下是一个使用`Computable`接口的示例代码：

public class Memoizer<A, V> implements Computable<A, V> {
    private final Map<A, Future<V>> cache = new ConcurrentHashMap<>();
    private final Computable<A, V> c;

    public Memoizer(Computable<A, V> c) {
        this.c = c;
    }

    public V compute(final A arg) throws InterruptedException {
        Future<V> f = cache.get(arg);
        if (f == null) {
            Callable<V> eval = new Callable<V>() {
                public V call() throws InterruptedException {
                    return c.compute(arg);
                }
            };
            FutureTask<V> ft = new FutureTask<>(eval);
            f = ft;
            cache.put(arg, ft);
            ft.run();
        }
        try {
            return f.get();
        } catch (ExecutionException e) {
            throw new RuntimeException(e.getCause());
        }
    }
}

该类实现了一个缓存功能，用于缓存计算结果，避免重复计算。在构造函数中传入一个实现了`Computable`接口的类，调用`compute`方法时，首先从缓存中查找结果，如果缓存中不存在，则调用传入的`Computable`实例的`compute`方法进行计算，并将结果缓存起来，然后再返回计算结果。如果缓存中已经存在结果，则直接返回缓存中的结果。

这就是`Computable`接口的使用方法，通过实现该接口，可以实现各种不同的计算逻辑，并且可以通过缓存优化计算性能。