|
Java example source code file (ListenableFuture.java)
The ListenableFuture.java Java example source code/* * Copyright (C) 2007 The Guava Authors * * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except * in compliance with the License. You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software distributed under the License * is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express * or implied. See the License for the specific language governing permissions and limitations under * the License. */ package com.google.common.util.concurrent; import com.google.common.annotations.GwtCompatible; import java.util.concurrent.Executor; import java.util.concurrent.Future; import java.util.concurrent.RejectedExecutionException; /** * A {@link Future} that accepts completion listeners. Each listener has an associated executor, and * it is invoked using this executor once the future's computation is {@linkplain Future#isDone() * complete}. If the computation has already completed when the listener is added, the listener will * execute immediately. * * <p>See the Guava User Guide article on * <a href="https://github.com/google/guava/wiki/ListenableFutureExplained"> * {@code ListenableFuture}</a>. * * <h3>Purpose * * <p>The main purpose of {@code ListenableFuture} is to help you chain together a graph of * asynchronous operations. You can chain them together manually with calls to methods like * {@link Futures#transform(ListenableFuture, Function, Executor) Futures.transform}, but you will * often find it easier to use a framework. Frameworks automate the process, often adding features * like monitoring, debugging, and cancellation. Examples of frameworks include: * * <ul> * <li>Dagger Producers * </ul> * * <p>The main purpose of {@link #addListener addListener} is to support this chaining. You will * rarely use it directly, in part because it does not provide direct access to the {@code Future} * result. (If you want such access, you may prefer {@link Futures#addCallback * Futures.addCallback}.) Still, direct {@code addListener} calls are occasionally useful: * * <pre> {@code * final String name = ...; * inFlight.add(name); * ListenableFuture<Result> future = service.query(name); * future.addListener(new Runnable() { * public void run() { * processedCount.incrementAndGet(); * inFlight.remove(name); * lastProcessed.set(name); * logger.info("Done with {0}", name); * } * }, executor);}</pre> * * <h3>How to get an instance * * <p>We encourage you to return {@code ListenableFuture} from your methods so that your users can * take advantage of the {@linkplain Futures utilities built atop the class}. The way that you will * create {@code ListenableFuture} instances depends on how you currently create {@code Future} * instances: * <ul> * <li>If you receive them from an {@code java.util.concurrent.ExecutorService}, convert that * service to a {@link ListeningExecutorService}, usually by calling * {@link MoreExecutors#listeningDecorator(java.util.concurrent.ExecutorService) * MoreExecutors.listeningDecorator}. * <li>If you manually call {@link java.util.concurrent.FutureTask#set} or a similar method, create * a {@link SettableFuture} instead. (If your needs are more complex, you may prefer * {@link AbstractFuture}.) * </ul> * * <p>Test doubles: If you need a {@code ListenableFuture} for your test, try a {@link * SettableFuture} or one of the methods in the {@link Futures#immediateFuture Futures.immediate*} * family. <b>Avoid creating a mock or stub {@code Future}. Mock and stub implementations are * fragile because they assume that only certain methods will be called and because they often * implement subtleties of the API improperly. * * <p>Custom implementation: Avoid implementing {@code ListenableFuture} from scratch. If you * can't get by with the standard implementations, prefer to derive a new {@code Future} instance * with the methods in {@link Futures} or, if necessary, to extend {@link AbstractFuture}. * * <p>Occasionally, an API will return a plain {@code Future} and it will be impossible to change * the return type. For this case, we provide a more expensive workaround in {@code * JdkFutureAdapters}. However, when possible, it is more efficient and reliable to create a {@code * ListenableFuture} directly. * * @author Sven Mawson * @author Nishant Thakkar * @since 1.0 */ @GwtCompatible public interface ListenableFuture<V> extends Future Other Java examples (source code examples)Here is a short list of links related to this Java ListenableFuture.java source code file: |
... this post is sponsored by my books ... | |
#1 New Release! |
FP Best Seller |
Copyright 1998-2021 Alvin Alexander, alvinalexander.com
All Rights Reserved.
A percentage of advertising revenue from
pages under the /java/jwarehouse
URI on this website is
paid back to open source projects.