jiangmo
jiangmo

CompletableFuture(异步神器)

CompletableFuture是java8提供更加完备的函数式异步工具。其继承了Future和CompletionStage接口。
CompletableFuture收集了所有ListenableFuture in Guava 和 SettableFuture的特征。此外，内置的lambda表达式使它更接近于Scala/Akka futures。这听起来好得令人难以置信，但是请继续读下去。CompletableFuture有两个主要的方面优于ol中的Future – 异步回调/转换，这能使得从任何时刻的任何线程都可以设置CompletableFuture的值。

CompletableFuture类实现了CompletionStage接口，首先我们需要理解这个接口的契约。它代表了一个特定的计算的阶段，可以同步或者异步的被完成。你可以把它看成一个计算流水线上的一个单元，最终会产生一个最终结果，这意味着几个CompletionStage可以串联起来，一个完成的阶段可以触发下一阶段的执行，接着触发下一次，接着……

除了实现CompletionStage接口， CompletableFuture也实现了future接口, 代表一个未完成的异步事件。CompletableFuture提供了方法，能够显式地完成这个future,所以它叫CompletableFuture。

Extract/modify wrapped value

Typically futures represent piece of code running by other thread. But that's not always the case. Sometimes you want to create a Future representing some event that you know will occur, e.g. JMS message arrival. So you have Future but there is no asynchronous job underlying this future. You simply want to complete (resolve) that future when JMS message arrives, and this is driven by an event. In this case you can simply create CompletableFuture, return it to your client and whenever you think your results are available, simply complete() the future and unlock all clients waiting on that future.

For starters you can simply create new CompletableFuture out of thin air and give it to your client:

public CompletableFuture ask() {
    final CompletableFuture future = new CompletableFuture<>();
    //...
    return future;
}

Notice that this future is not associated wtih any Callable, no thread pool, no asynchronous job. If now the client code calls ask().get() it will block forever. If it registers some completion callbacks, they will never fire. So what's the point? Now you can say:

future.complete("42")

...and at this very moment all clients blocked on Future.get() will get the result string. Also completion callbacks will fire immediately. This comes quite handy when you want to represent a task in the future, but not necessarily computational task running on some thread of execution. CompletableFuture.complete() can only be called once, subsequent invocations are ignored. But there is a back-door called CompletableFuture.obtrudeValue(...) which overrides previous value of the Future with new one. Use with caution.

相当于消息总线的广播？！

Sometimes you want to signal failure. As you know Future objects can handle either wrapped result or exception. If you want to pass some exception further, there is CompletableFuture.completeExceptionally(ex) (and obtrudeException(ex) evil brother that overrides the previous exception). completeExceptionally() also unlock all waiting clients, but this time throwing an exception from get(). Speaking of get(), there is also CompletableFuture.join() method with some subtle changes in error handling. But in general they are the same. And finally there is also CompletableFuture.getNow(valueIfAbsent) method that doesn't block but if the Future is not completed yet, returns default value. Useful when building robust systems where we don't want to wait too much.

Last static utility method is completedFuture(value) that returns already completed Future object. Might be useful for testing or when writing some adapter layer.

Creating and obtaining CompletableFuture

OK, so is creating CompletableFuture manually our only option? Not quite. Just as with normal Futures we can wrap existing task with CompletableFuture using the following family of factory methods:

static  CompletableFuture supplyAsync(Supplier supplier);
static  CompletableFuture supplyAsync(Supplier supplier, Executor executor);
static CompletableFuture runAsync(Runnable runnable);
static CompletableFuture runAsync(Runnable runnable, Executor executor);

Methods that do not take an Executor as an argument but end with ...Async will use ForkJoinPool.commonPool() (global, general purpose pool introduces in JDK 8). This applies to most methods in CompletableFuture class. runAsync() is simple to understand, notice that it takes Runnable, therefore it returns CompletableFuture as Runnable doesn't return anything. If you need to process something asynchronously and return result, use Supplier:

final CompletableFuture future = CompletableFuture.supplyAsync(() -> {
    //...long running...
    return "42";
}, executor);

Transforming and acting on one CompletableFuture (thenApply)

So I said that CompletableFuture is superior to Future but you haven't yet seen why? Simply put, it's because CompletableFuture is a monad and a functor. Not helping I guess? Both Scala and JavaScript allow registering asynchronous callbacks when future is completed. We don't have to wait and block until it's ready. We can simply say: run this function on a result, when it arrives. Moreover, we can stack such functions, combine multiple futures together, etc. For example if we have a function from Stringto Integer we can turn CompletableFuture to CompletableFuture without unwrapping it. This is achieved with thenApply() family of methods:

 CompletableFuture thenApply(Function fn);
 CompletableFuture thenApplyAsync(Function fn);
 CompletableFuture thenApplyAsync(Function fn, Executor executor);

As stated before ...Async versions are provided for most operations on CompletableFuture thus I will skip them in subsequent sections. Just remember that first method will apply function within the same thread in which the future completed while the remaining two will apply it asynchronously in different thread pool.

Let's see how thenApply() works:

CompletableFuture f1 = //...
CompletableFuture f3 = 
    f1.thenApply(Integer::parseInt).thenApply(r -> r * r * Math.PI);

You see a sequence of transformations here. From String to Integer and then to Double. But what's most important, these transformations are neither executed immediately nor blocking. They are simply remembered and when original f1 completes they are executed for you. If some of the transformations are time-consuming, you can supply your own Executor to run them asynchronously. Notice that this operation is equivalent to monadic map in Scala.

Running code on completion (thenAccept/thenRun)

CompletableFuture thenAccept(Consumer block);
CompletableFuture thenRun(Runnable action);

...Async variants are available as well for both methods, with implicit and explicit executor.I can't emphasize this enough: thenAccept()/thenRun() methods do not block (even without explicit executor).Treat them like an event listener/handler that you attach to a future and that will execute some time in the future. "Continuing" message will appear immediately, even if future is not even close to completion.

Error handling of single CompletableFuture

So far we only talked about result of computation. But what about exceptions? Can we handle them asynchronously as well? Sure!

CompletableFuture safe = 
    future.exceptionally(ex -> "We have a problem: " + ex.getMessage());

exceptionally() takes a function that will be invoked when original future throws an exception. We then have an opportunity to recover by transforming this exception into some value compatible with Future's type. Further transformations of safe will no longer yield an exception but instead a String returned from supplied function.

A more flexible approach is handle() that takes a function receiving either correct result or exception:

CompletableFuture safe = future.handle((ok, ex) -> {
    if (ok != null) {
        return Integer.parseInt(ok);
    } else {
        log.warn("Problem", ex);
        return -1;
    }
});

handle() is called always, with either result or exception argument being not-null. This is a one-stop catch-all strategy.

Combining two CompletableFuture together

Asynchronous processing of one CompletableFuture is nice but it really shows its power when multiple such futures are combined together in various ways.

Combining (chaining) two futures (thenCompose())

Sometimes you want to run some function on future's value (when it's ready). But this function returns future as well. CompletableFuture should be smart enough to understand that the result of our function should now be used as top-level future, as opposed to CompletableFuture>. Method thenCompose() is thus equivalent to flatMap in Scala:

 CompletableFuture thenCompose(Function> fn);

...Async variations are available as well. Example below, look carefully at the types and the difference between thenApply() (map) and thenCompose() (flatMap) when applying a calculateRelevance() function returning CompletableFuture:

CompletableFuture docFuture = //...
 
CompletableFuture> f =
    docFuture.thenApply(this::calculateRelevance);
 
CompletableFuture relevanceFuture =
    docFuture.thenCompose(this::calculateRelevance);
 
//...
 
private CompletableFuture calculateRelevance(Document doc)

thenCompose() is an essential method that allows building robust, asynchronous pipelines, without blocking or waiting for intermediate steps.

Transforming values of two futures (thenCombine())

While thenCompose() is used to chain one future dependent on the other, thenCombine combines two independent futures when they are both done:

 CompletableFuture thenCombine(CompletableFuture other, BiFunction fn)

...Async variations are available as well. Imagine you have two CompletableFutures, one that loads Customer and other that loads nearest Shop. They are completely independent from each other,but when both of them are completed, you want to use their values to calculate Route. Here is a stripped example:

CompletableFuture customerFuture = loadCustomerDetails(123);
CompletableFuture shopFuture = closestShop();
CompletableFuture routeFuture = 
    customerFuture.thenCombine(shopFuture, (cust, shop) -> findRoute(cust, shop));
//...
private Route findRoute(Customer customer, Shop shop) //...

Notice that in Java 8 you can replace (cust, shop) -> findRoute(cust, shop) with simple this::findRoute method reference:

customerFuture.thenCombine(shopFuture, this::findRoute);

So you get the idea. We have customerFuture and shopFuture. Then routeFuture wraps them and "waits" for both to complete. When both of them are ready, it runs our supplied function that combines results (findRoute()). Thus routeFuture will complete when two underlying futures are resolved and findRoute() is done.

好用！自己实现该咋做？实现原理是啥？

Waiting for both CompletableFutures to complete

If instead of producing new CompletableFuture combining both results we simply want to be notified when they finish, we can use thenAcceptBoth()/runAfterBoth() family of methods (...Async variations are available as well). They work similarly to thenAccept() and thenRun() but wait for two futures instead of one:

 CompletableFuture thenAcceptBoth(CompletableFuture other, BiConsumer block);

CompletableFuture runAfterBoth(CompletableFuture other, Runnable action)

Imagine that in the example above, instead of producing new CompletableFuture you simply want send some event or refresh GUI immediately. This can be easily achieved with thenAcceptBoth():

customerFuture.thenAcceptBoth(shopFuture, (cust, shop) -> {
    final Route route = findRoute(cust, shop);
    //refresh GUI with route
});

I hope I'm wrong but maybe some of you are asking themselves a question: why can't I simply block on these two futures? Like here:

Future customerFuture = loadCustomerDetails(123);
Future shopFuture = closestShop();
findRoute(customerFuture.get(), shopFuture.get());

Well,of course you can. But the whole point of CompletableFuture is to allow asynchronous, event driven programming model instead of blocking and eagerly waiting for result.So functionally two code snippets above are equivalent, but the latter unnecessarily occupies one thread of execution.

Waiting for first CompletableFuture to complete

Another interesting part of the CompletableFuture API is the ability to wait for first (as opposed to all) completed future. This can come handy when you have two tasks yielding result of the same type and you only care about response time, not which task resulted first. API methods (...Async variations are available as well):

CompletableFuture acceptEither(CompletableFuture other, Consumer block);

CompletableFuture runAfterEither(CompletableFuture other, Runnable action)

As an example say you have two systems you integrate with. One has smaller average response times but high standard deviation. Other one is slower in general, but more predictable. In order to take best of both worlds (performance and predictability) you call both systems at the same time and wait for the first one to complete. Normally it will be the first one, but in case it became slow, second one finishes in an acceptable time:

CompletableFuture fast = fetchFast();
CompletableFuture predictable = fetchPredictably();
fast.acceptEither(predictable, s -> {
    System.out.println("Result: " + s);
});

s represents String reply either from fetchFast() or from fetchPredictably(). We neither know nor care.

Transforming first completed

applyToEither() is an older brother of acceptEither(). While the latter simply calls some piece of code when faster of two futures complete, applyToEither() will return a new future. This future will complete when first of the two underlying futures complete. API is a bit similar (...Async variations are available as well):

 CompletableFuture applyToEither(CompletableFuture other, Function fn)

The extra fn function is invoked on the result of first future that completed. I am not really sure what's the purpose of such a specialized method, after all one could simply use: fast.applyToEither(predictable).thenApply(fn). Since we are stuck with this API but we don't really need extra function application, I will simply use Function.identity() placeholder:

CompletableFuture fast = fetchFast();
CompletableFuture predictable = fetchPredictably();
CompletableFuture firstDone = 
    fast.applyToEither(predictable, Function.identity());

firstDone future can then be passed around. Notice that from the client perspective the fact that two futures are actually behind firstDone is hidden. Client simply waits for future to complete and applyToEither() takes care of notifying the client when any of the two finish first.

Combining multiple CompletableFuture together

So we now know how to wait for two futures to complete (using thenCombine()) and for the first one to complete (applyToEither()). But can it scale to arbitrary number of futures? Sure, using static helper methods:

static CompletableFuture allOf(CompletableFuture... cfs)
static CompletableFuture anyOf(CompletableFuture... cfs)
 
 
allOf() takes an array of futures and returns a future that completes when all of the underlying futures are completed (barrier waiting for all). anyOf() on the other hand will wait only for the fastest of the underlying futures. Please look at the generic type of returned futures. Not quite what you would expect? We will take care of this issue in the next article.
 
 
学习例子
 
 
public class TCompletableFuture {

    static void completedFutureExample() throws InterruptedException {
        CompletableFuture cf = CompletableFuture.completedFuture("message");
        System.out.println(cf.isDone());
        // getNow(null)方法在future完成的情况下会返回结果，就比如上面这个例子，否则返回null (传入的参数)。
        System.out.println(cf.getNow(null));

        // 在前一个阶段上应用函数
        CompletableFuture cfApply = CompletableFuture.completedFuture("message").thenApply(s -> {
            return s.toUpperCase();
        });
        System.out.println("MESSAGE:" + cfApply.getNow(null));

        // 在前一个阶段上异步应用函数
        CompletableFuture cfApplyAsync = CompletableFuture.completedFuture("message").thenApplyAsync(s -> {
            try {
                TimeUnit.SECONDS.sleep(1);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            return s.toUpperCase();
        });
        System.out.println(cfApplyAsync.getNow(null));
        System.out.println("MESSAGE:" + cfApplyAsync.join());


    }

    static void runAsyncExample() throws InterruptedException {
        // CompletableFuture的方法如果以Async结尾，它会异步的执行(没有指定executor的情况下)，
        // 异步执行通过ForkJoinPool实现， 它使用守护线程去执行任务。
        // 注意这是CompletableFuture的特性， 其它CompletionStage可以override这个默认的行为。
        CompletableFuture cf = CompletableFuture.runAsync(() -> {
            System.out.println(Thread.currentThread().isDaemon());
            try {
                TimeUnit.SECONDS.sleep(2);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });
        System.out.println(cf.isDone());
        TimeUnit.SECONDS.sleep(3);
        System.out.println(cf.isDone());
    }

    static ExecutorService executor = Executors.newFixedThreadPool(3, new ThreadFactory() {
        int count = 1;

        @Override
        public Thread newThread(Runnable runnable) {
            return new Thread(runnable, "custom-executor-" + count++);
        }
    });

    static void thenApplyAsyncWithExecutorExample() {

        // 使用定制的Executor在前一个阶段上异步应用函数
        CompletableFuture cf = CompletableFuture.completedFuture("message").thenApplyAsync(s -> {
            System.out.println(Thread.currentThread().getName().startsWith("custom-executor-"));
            System.out.println(Thread.currentThread().isDaemon());
            return delayStringUp(s);
        }, executor);

        System.out.println(cf.getNow(null));
        System.out.println("MESSAGE" + cf.join());
    }

    static void thenAcceptExample() {
        // 如果下一阶段接收了当前阶段的结果，但是在计算的时候不需要返回值(它的返回类型是void)，
        // 那么它可以不应用一个函数，而是一个消费者， 调用方法也变成了thenAccept:
        StringBuilder result = new StringBuilder();
        // 消费者同步地执行
        CompletableFuture.completedFuture("thenAccept message")
                .thenAccept(s -> result.append(s));
        System.out.println("Result :" + result);

        // 消费者同步地执行
        CompletableFuture cfAsync = CompletableFuture.completedFuture("thenAccept message")
                .thenAcceptAsync(s -> result.append(s));
        // join 同步等待
        cfAsync.join();
        System.out.println("Result :" + result);
    }

    static void completeExceptionallyExample() {
        // 完成计算异常
        CompletableFuture cf = CompletableFuture.completedFuture("message").thenApplyAsync(s -> delayStringUp(s));

        // 创建了一个分离的handler阶段： exceptionHandler， 它处理异常异常，在异常情况下返回message upon cancel。
        CompletableFuture exceptionHandler = cf.handle((s, throwExcept) -> {
            return (throwExcept != null) ? "message upon cancel" : "";
        });

        /**
         * If not already completed, causes invocations of {@link #get()}
         * and related methods to throw the given exception.
         */
        cf.completeExceptionally(new RuntimeException("completed exceptionally"));

        System.out.println("Was not completed exceptionally" + cf.isCompletedExceptionally());

        try {
            // 显式地用异常完成第二个阶段。 在阶段上调用join方法，它会执行大写转换，然后抛出CompletionException
            // （正常的join会等待1秒，然后得到大写的字符串。不过我们的例子还没等它执行就完成了异常）， 然后它触发了handler阶段。
            cf.join();
            System.out.println("Should have thrown an exception");
        } catch (CompletionException ex) { // just for testing
            System.out.println("completed exceptionally" + ex.getCause().getMessage());
        }

        System.out.println("message upon cancel" + exceptionHandler.join());
    }

    private static String delayStringUp(String s) {
        try {
            TimeUnit.SECONDS.sleep(2);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        return s.toUpperCase();
    }

    static void cancelExample() {
        // 完成计算异常

        // 对于CompletableFuture类，布尔参数并没有被使用，这是因为它并没有使用中断去取消操作，
        // 相反，cancel等价于completeExceptionally(new CancellationException())。
        CompletableFuture cf = CompletableFuture.completedFuture("message").thenApplyAsync(s -> delayStringUp(s));
        CompletableFuture cf2 = cf.exceptionally(throwable -> "canceled message");
        System.out.println("Was not canceled" + cf.cancel(true));
        System.out.println("Was not completed exceptionally" + cf.isCompletedExceptionally());
        System.out.println("canceled message" + cf2.join());
    }

    static void applyToEitherExample() {
        // 在两个完成的阶段其中之一上应用函数

        String original = "Message";
        CompletableFuture cf1 = CompletableFuture.completedFuture(original)
                .thenApplyAsync(s -> delayStringUp(s));
        CompletableFuture cf2 = cf1.applyToEither(
                CompletableFuture.completedFuture(original).thenApplyAsync(s -> delayStringUp(s)),
                s -> s + " from applyToEither");
        System.out.println((String) cf2.join());
    }

    static void acceptEitherExample() {
        // acceptEither 在两个完成的阶段其中之一上调用消费函数
        String original = "Message";
        StringBuilder result = new StringBuilder();
        CompletableFuture cf = CompletableFuture.completedFuture(original)
                .thenApplyAsync(s -> delayStringUp(s))
                .acceptEither(CompletableFuture.completedFuture(original).thenApplyAsync(s -> delayStringUp(s)),
                        s -> result.append(s).append("acceptEither"));
        cf.join();
        System.out.println("Result was empty" + result.toString().endsWith("acceptEither"));
    }

    static void runAfterBothExample() {
        // runAfterBoth  在两个阶段都执行完后运行一个 Runnable
        String original = "Message";
        StringBuilder result = new StringBuilder();
        CompletableFuture.completedFuture(original).thenApply(String::toUpperCase).runAfterBoth(
                CompletableFuture.completedFuture(original).thenApply(String::toLowerCase),
                () -> result.append("done"));
        System.out.println("Result :" + result);
    }

    static void thenAcceptBothExample() {
        // thenAcceptBoth 使用BiConsumer处理两个阶段的结果
        String original = "Message";
        StringBuilder result = new StringBuilder();
        CompletableFuture.completedFuture(original).thenApply(String::toUpperCase).thenAcceptBoth(
                CompletableFuture.completedFuture(original).thenApply(String::toLowerCase),
                (s1, s2) -> result.append(s1 + s2));
        System.out.println("MESSAGEmessage" + result.toString());
    }

    static void thenCombineExample() {
        // 如果CompletableFuture依赖两个前面阶段的结果， 它复合两个阶段的结果再返回一个结果，
        // 我们就可以使用thenCombine()函数。
        // 整个流水线是同步的，所以getNow()会得到最终的结果
        String original = "Message";
        CompletableFuture cf = CompletableFuture.completedFuture(original).thenApply(s -> delayStringUp(s))
                .thenCombine(CompletableFuture.completedFuture(original).thenApply(s -> delayStringUp(s)),
                        (s1, s2) -> s1 + s2);
        System.out.println("MESSAGEmessage" + cf.getNow(null));
    }

    static void thenCombineAsyncExample() {
        // 异步使用BiFunction处理两个阶段的结果

        // Actions supplied for dependent completions of non-async methods may be performed by the thread
        // that completes the current CompletableFuture, or by any other caller of a completion method

        // 所以我们需要join方法等待结果的完成。
        String original = "Message";
        CompletableFuture cf = CompletableFuture.completedFuture(original)
                .thenApplyAsync(s -> delayStringUp(s))
                .thenCombine(CompletableFuture.completedFuture(original).thenApplyAsync(s -> delayStringUp(s)),
                        (s1, s2) -> s1 + s2);
        System.out.println("MESSAGEmessage" + cf.join());
    }

    static void thenComposeExample() {
        // 这个方法等待第一个阶段的完成(大写转换)，
        // 它的结果传给一个指定的返回CompletableFuture函数，
        // 它的结果就是返回的CompletableFuture的结果。
        String original = "Message";
        CompletableFuture cf = CompletableFuture.completedFuture(original).thenApply(s -> delayStringUp(s))
                .thenCompose(
                        upper -> CompletableFuture.completedFuture(original).thenApply(s -> delayStringUp(s)).thenApply(s -> upper + s)
                );
        System.out.println("MESSAGEmessage" + cf.join());
    }

    static void anyOfExample() {
        // 当几个阶段中的一个完成，创建一个完成的阶段

        // 本例中这些阶段都是同步地执行(thenApply), 从anyOf中创建的CompletableFuture会立即完成，
        // 这样所有的阶段都已完成，我们使用whenComplete(BiConsumer action)处理完成的结果。
        StringBuilder result = new StringBuilder();
        List messages = Arrays.asList("a", "b", "c");
        List futures = messages.stream()
                .map(msg -> CompletableFuture.completedFuture(msg).thenApply(s -> delayStringUp(s)))
                .collect(Collectors.toList());

        CompletableFuture.anyOf(futures.toArray(new CompletableFuture[futures.size()])).whenComplete((res, th) -> {
            if (th == null) {
                System.out.println("res = " + res);
                result.append(res);
            }
        });
        System.out.println("result = " + result);
    }

    static void allOfExample() {
        // 同步的当所有的阶段都完成后创建一个阶段
        StringBuilder result = new StringBuilder();
        List messages = Arrays.asList("a", "b", "c");
        List futures = messages.stream()
                .map(msg -> CompletableFuture.completedFuture(msg).thenApply(s -> delayStringUp(s)))
                .collect(Collectors.toList());
        CompletableFuture.allOf(futures.toArray(new CompletableFuture[futures.size()])).whenComplete((v, th) -> {
            futures.forEach(cf -> {
                System.out.println(cf.getNow(null));
                result.append(cf.getNow(null));
            });
            result.append("done");
        });
        System.out.println("result = " + result);
    }

    static void allOfAsyncExample() {
        // 使用thenApplyAsync()替换那些单个的CompletableFutures的方法，
        // allOf()会在通用池中的线程中异步地执行。所以我们需要调用join方法等待它完成。
        StringBuilder result = new StringBuilder();
        List messages = Arrays.asList("a", "b", "c");
        List futures = messages.stream()
                .map(msg -> CompletableFuture.completedFuture(msg).thenApplyAsync(s -> delayStringUp(s)))
                .collect(Collectors.toList());
        CompletableFuture allOf = CompletableFuture.allOf(futures.toArray(new CompletableFuture[futures.size()]))
                .whenComplete((v, th) -> {
                    futures.forEach(cf -> {
                        System.out.println(cf.getNow(null));
                        result.append(cf.getNow(null));
                    });
                    result.append("done");
                });
        allOf.join();
        System.out.println("result = " + result);

    }

    /**
     * 1 首先异步调用cars方法获得Car的列表，它返回CompletionStage场景。cars消费一个远程的REST API。
     * 2 然后我们复合一个CompletionStage填写每个汽车的评分，通过rating(manufacturerId)返回一个CompletionStage,
     * 它会异步地获取汽车的评分(可能又是一个REST API调用)
     * 3 当所有的汽车填好评分后，我们结束这个列表，所以我们调用allOf得到最终的阶段， 它在前面阶段所有阶段完成后才完成。
     * 4 在最终的阶段调用whenComplete(),我们打印出每个汽车和它的评分。
     */

    static void simpleExample(){
        // cars().thenCompose(cars -> {
        //     List updatedCars = cars.stream()
        //             .map(car -> rating(car.manufacturerId).thenApply(r -> {
        //                 car.setRating(r);
        //                 return car;
        //             })).collect(Collectors.toList());
        //
        //     CompletableFuture done = CompletableFuture
        //             .allOf(updatedCars.toArray(new CompletableFuture[updatedCars.size()]));
        //
        //     return done.thenApply(v -> updatedCars.stream().map(CompletionStage::toCompletableFuture)
        //             .map(CompletableFuture::join).collect(Collectors.toList()));
        //
        // }).whenComplete((cars, th) -> {
        //     if (th == null) {
        //         cars.forEach(System.out::println);
        //     } else {
        //         throw new RuntimeException(th);
        //     }
        // }).toCompletableFuture().join();
    }
}

 
 
Ref:
 https://www.nurkiewicz.com/2013/05/java-8-definitive-guide-to.html
 http://www.importnew.com/10815.html
 https://mahmoudanouti.wordpress.com/2018/01/26/20-examples-of-using-javas-completablefuture/
 http://www.importnew.com/28319.html
 

                            
                        
                    
                    
                    

                    
                    
                    

                
                

                    
                

            
        
    
    

        
你可能感兴趣的:(CompletableFuture(异步神器))

        

            

                
    
                    
  • QQ群采集助手，精准引流必备神器
                        2401_87347160
其他经验分享
                        
    功能概述微信群查找与筛选工具是一款专为微信用户设计的辅助工具，它通过关键词搜索功能，帮助用户快速找到相关的微信群，并提供筛选是否需要验证的群组的功能。主要功能关键词搜索：用户可以输入关键词，工具将自动查找包含该关键词的微信群。筛选功能：工具提供筛选机制，用户可以选择是否只显示需要验证或不需要验证的群组。精准引流：通过上述功能，用户可以更精准地找到目标群组，进行有效的引流操作。3.设备需求该工具可以
    
                    
    • 
                    
  • ios GCD
                        _Waiting_

                        
    1.GCD任务和队列学习GCD之前，先来了解GCD中两个核心概念：任务和队列。任务：就是执行操作的意思，换句话说就是你在线程中执行的那段代码。在GCD中是放在block中的。执行任务有两种方式：同步执行（sync）和异步执行（async）。两者的主要区别是：是否等待队列的任务执行结束，以及是否具备开启新线程的能力。同步执行（sync）：同步添加任务到指定的队列中，在添加的任务执行结束之前，会一直等
    
                    
    • 
                    
  • Python神器！WEB自动化测试集成工具 DrissionPage
                        亚丁号
python开发语言
                        
    一、前言用requests做数据采集面对要登录的网站时，要分析数据包、JS源码，构造复杂的请求，往往还要应付验证码、JS混淆、签名参数等反爬手段，门槛较高。若数据是由JS计算生成的，还须重现计算过程，体验不好，开发效率不高。使用浏览器，可以很大程度上绕过这些坑，但浏览器运行效率不高。因此，这个库设计初衷，是将它们合而为一，能够在不同须要时切换相应模式，并提供一种人性化的使用方法，提高开发和运行效率
    
                    
    • 
                    
  • 06选课支付模块之基于消息队列发送支付通知消息
                        echo 云清
学成在线javarabbitmq消息队列支付通知学成在线
                        
    消息队列发送支付通知消息需求分析订单服务作为通用服务，在订单支付成功后需要将支付结果异步通知给其他对接的微服务，微服务收到支付结果根据订单的类型去更新自己的业务数据技术方案使用消息队列进行异步通知需要保证消息的可靠性即生产端将消息成功通知到服务端：消息发送到交换机-->由交换机发送到队列-->消费者监听队列，收到消息进行处理，参考文章02-使用Docker安装RabbitMQ-CSDN博客生产者确
    
                    
    • 
                    
  • windows下python opencv ffmpeg读取摄像头实现rtsp推流 拉流
                        图像处理大大大大大牛啊
opencv实战代码讲解视觉图像项目windowspythonopencv
                        
    windows下pythonopencvffmpeg读取摄像头实现rtsp推流拉流整体流程1.下载所需文件1.1下载rtsp推流服务器1.2下载ffmpeg2.开启RTSP服务器3.opencv读取摄像头并调用ffmpeg进行推流4.opencv进行拉流5.opencv异步拉流整体流程1.下载所需文件1.1下载rtsp推流服务器下载RTSP服务器下载页面https://github.com/blu
    
                    
    • 
                    
  • 【Java】已解决：java.util.concurrent.CompletionException
                        屿小夏
java开发语言
                        
    文章目录一、分析问题背景出现问题的场景代码片段二、可能出错的原因三、错误代码示例四、正确代码示例五、注意事项已解决：java.util.concurrent.CompletionException一、分析问题背景在Java并发编程中，java.util.concurrent.CompletionException是一种常见的运行时异常，通常在使用CompletableFuture进行异步计算时出现
    
                    
    • 
                    
  • 效率神器来了：AI工具手把手教你快速提升工作效能
                        kkai人工智能
人工智能学习媒体aichatgpt
                        
    随着科技的进步，AI工具已经成为提升工作效率的关键手段。本文将介绍一些实用的AI工具和方法，帮助你自动化繁琐的重复性任务、优化数据管理、促进团队协作与沟通，并提升决策质量。背景：OOPAI-免费问答学习交流-GPT自动化重复性任务Zapier：Zapier可以自动化多个应用程序之间的工作流程。例如，它能自动将Gmail中的附件保存至GoogleDrive，或在你发布新文章时，自动分享至社交媒体平台
    
                    
    • 
                    
  • 淘宝网优惠券，你的购物神器，你知道吗？
                        氧惠超好用

                        
    淘宝网作为中国最大的综合性网络零售平台，吸引了无数消费者的目光。在淘宝网上，我们不仅可以找到丰富多样的商品，还可以通过各种促销活动享受到购物的乐趣。其中，淘宝网优惠券就是一项备受消费者喜爱的福利。那么，淘宝网优惠券究竟有何魅力，能够让我们在购物时更加得心应手呢？淘宝网优惠券作为一种促销手段，为消费者提供了实实在在的购物优惠。无论是店铺优惠券、平台优惠券还是特定商品优惠券，都能在一定程度上降低购物成
    
                    
    • 
                    
  • Windows安装ciphey编码工具，附一道ciscn编码题例
                        im-Miclelson
CTF工具网络安全
                        
    TA是什么一款智能化的编码分析解码工具，对于CTF中复杂性编码类题目可以快速攻破。编码自动分析解码的神器。如何安装Windows环境Python3.864位（最新的版本不兼容，32位的也不行）PIP直接安装pipinstallciphey-ihttps://pypi.mirrors.ustc.edu.cn/simple/安装后若是出现报错请根据错误代码行数找到对应文件，r修改成rb即可。使用标准语
    
                    
    • 
                    
  • 【JS】前端文件读取FileReader操作总结
                        程序员-张师傅
前端前端javascript开发语言
                        
    前端文件读取FileReader操作总结FileReader是JavaScript中的一个WebAPI，它允许web应用程序异步读取用户计算机上的文件（或原始数据缓冲区）的内容，例如读取文件以获取其内容，并在不将文件发送到服务器的情况下在客户端使用它。这对于处理图片、文本文件等非常有用，尤其是当你想要在用户界面中即时显示文件内容或进行文件预览时。创建FileReader对象首先，你需要创建一个Fi
    
                    
    • 
                    
  • UI 自动化的页面对象管理神器 PO-Manager
                        TesterHome

                        
    原文由alex发表于TesterHome社区网站，点击原文链接可于作者直接交流。做UI自动化的同学都知道，UI自动化一个难点就是页面元素的变化，让自动化维护成为一个痛点。在此，为了减轻这个痛点，我在基于Page-Object模式的基础上开发了页面对象维护的工具。该工具为vscode的一个插件，可以通过vscode插件市场搜索PO-Manager来下载安装本文中的页面对象库文件基于json.一个元素
    
                    
    • 
                    
  • Lombok：Java开发者的代码简化神器【后端 17】
                        终末圆
Java后端java开发语言mysql数据库后端springbootpython
                        
    Lombok：Java开发者的代码简化神器在Java开发中，我们经常需要编写大量的样板代码，如getter、setter、equals、hashCode、toString等方法。这些代码虽然基础且必要，但往往占据了大量开发时间，且容易在属性变更时引发错误。幸运的是，Lombok这个Java库通过注解的方式，为我们提供了一种高效的解决方案。本文将详细介绍Lombok的使用及其优势。什么是Lombok
    
                    
    • 
                    
  • Spring @Async 深度解读：默认线程池执行器的配置与优化
                        小码快撩
springjava前端
                        
    在Spring中，@Async注解用于异步执行方法。默认情况下，@Async注解的任务是由一个线程池执行的。然而，这个默认的线程池是如何初始化的呢？本文将深入探讨这一过程，帮助你理解Spring异步任务背后的线程池执行器的初始化原理。1.@Async的基本使用首先，让我们快速回顾一下@Async的基本用法。@Async通常用于标注在需要异步执行的方法上，比如：@Servicepublicclass
    
                    
    • 
                    
  • 保温壶哪个品牌质量好？保温壶十大品牌排行榜
                        金钱保卫科长

                        
    保温壶日常家用或者出门时候带上，都是非常方便的提供热水的神器！保温壶主要针对家居、会议等场所的固有特征而专业开发的一种新的产品类别，其前身由保温瓶、保温杯演变而来，也可称为咖啡壶。保温壶哪个品牌质量好？保温壶十大品牌排行榜淘宝/京东/拼多多/唯品会/外卖等平台超级红包|活动无门槛红包https://www.chaojiyouhui1-虎牌（Tiger）Tiger虎牌创于1923年日本，以生产热水瓶
    
                    
    • 
                    
  • 全自动解密解码神器 — Ciphey
                        K'illCode
python_模块pythonvscode
                        
    Ciphey是一个使用自然语言处理和人工智能的全自动解密/解码/破解工具。简单地来讲，你只需要输入加密文本，它就能给你返回解密文本。就是这么牛逼。有了Ciphey，你根本不需要知道你的密文是哪种类型的加密，你只知道它是加密的，那么Ciphey就能在3秒甚至更短的时间内给你解密，返回你想要的大部分密文的答案。下面就给大家介绍Ciphey的实战使用教程。1.准备开始之前，你要确保Python和pip已
    
                    
    • 
                    
  • 为什么Node.js不适合CPU密集型应用？
                        weixin_54503231
node.js
                        
    Node.js不适合CPU密集型应用的原因主要基于其设计理念和核心特性，具体可以归纳为以下几点：单线程模型Node.js采用单线程模型来处理用户请求和异步I/O操作。虽然这种模型在处理高并发I/O密集型任务时非常高效，因为它避免了传统多线程模型中的线程上下文切换开销，但这也意味着它不能充分利用现代多核CPU的计算能力。对于需要大量计算资源的CPU密集型应用，单线程模型会成为瓶颈，导致应用性能受限。
    
                    
    • 
                    
  • rabbitmq
                        楚楚ccc
Java系列rabbitmq分布式
                        
    1.消息服务概述、rabbitmq核心概念消息服务概述：大多数应用中，可通过消息服务中间件来提升系统异步通信，扩展解耦能力两个重要概念：消息代理(messagebroker)和目的地(destination)。当消息发送者者发出消息后，将由消息代理接管，消息代理保证将消息传递至目的地两种形式的目的地：队列(queue):点对点的消息通信(point-to-point)主题(topic):发布(pu
    
                    
    • 
                    
  • 使用 RabbitMQ 实现秒杀订单系统的异步消息处理
                        c137范特西
rabbitmq分布式
                        
    使用RabbitMQ实现秒杀订单系统的异步消息处理在秒杀系统中，如何确保高并发环境下的订单处理稳定高效是个很大的挑战。为了解决这个问题，我们通常会引入消息队列，通过异步处理来削峰填谷。这篇文章将详细讲解如何使用RabbitMQ来设计一个秒杀订单系统的异步消息处理流程，重点是如何使用交换机（Exchange）、队列（Queue）、路由键（RoutingKey）以及死信队列（DeadLetterQue
    
                    
    • 
                    
  • springboot与日志
                        最后的夏t

                        
    日志1、日志框架小张；开发一个大型系统；1、System.out.println("")；将关键数据打印在控制台；去掉？写在一个文件？2、框架来记录系统的一些运行时信息；日志框架；zhanglogging.jar；3、高大上的几个功能？异步模式？自动归档？xxxx？zhanglogging-good.jar？4、将以前框架卸下来？换上新的框架，重新修改之前相关的API；zhanglogging-p
    
                    
    • 
                    
  • ⭐Unity 安卓环境中正确地读取和处理 XML 文件
                        惊鸿醉
Unityunityandroidxml
                        
    写了一个选择题Demo，电脑包和编辑器内无问题，但是打包安卓手机之后题目无法正常使用，想到的是安卓环境中正确地读取文件的问题改进方案：1.由于XmlDocument.Load方法在Android上的路径问题（由于文件位于APK内部，无法像在文件系统中那样直接访问），需要先使用UnityWebRequest来异步加载文件内容，然后再解析XML。2.异步处理：修改你的代码，以支持异步文件加载和处理，这
    
                    
    • 
                    
  • OmicsTools除b站教学视频外已整理的零代码生信全流程分析文档
                        邢博士谈科教
医学科研生信分析r语言数据可视化数据挖掘数据分析生信医学生信分析
                        
    OmicsTools软件介绍和下载安装配置软件简介我开发了一款本地电脑无限使用的零代码生信数据分析作软图神器电脑软件OmicsTools，欢迎大家使用OmicsTools进行生物医学科研数据分析和作图，该软件件能让大家在不需要任何编程和代码编写的基础上，分析次数没有限制，可以无限使用，让您在自己电脑上快速进行大量的生信分析和加速大家的科研。OmicsTools生信分析电脑软件可以做医学生物生信各个
    
                    
    • 
                    
  • 如何挑选一个专卖莆田鞋app软件？你的首选购物神器app
                        微香之窗

                        
    如何挑选一个专卖莆田鞋app软件？你的首选购物神器app在数字化浪潮席卷全球的今天，手机app已成为人们生活中不可或缺的一部分。当我们提及专卖莆田鞋的app软件时，不禁让人想起那句古话：“工欲善其事，必先利其器。”这些app就如同锐利的工具，助力我们在浩渺的网络世界中精准定位到心仪的莆田鞋。一、狮王工作室：专注与专业的典范狮王工作室以其专业的眼光和专注的态度，为广大莆田鞋爱好者提供了一个优质的购鞋
    
                    
    • 
                    
  • java ajax_Java Ajax入门
                        孤独患喆
javaajax
                        
    接下来整理一下Ajax相关的内容，AJAX(asynchronousjsandxml)，即异步的JavaScript和xml，它的主要作用就是让页面不必等待服务器返回整个页面信息，而可以通过异步的方式给服务器发送数据和获取数据，对页面进行局部刷新，是一种提高用户体验的技术。同步和异步同步和异步的主要区别如下；(1)同步：一个响应结束后才能发送下一个请求，页面在请求期间不能做其他事情。(2)异步：不
    
                    
    • 
                    
  • html加载界面发送ajax请求
                        足球数据分析
htmlajax前端
                        
    html加载界面发送ajax请求makeAjaxRequest();functionmakeAjaxRequest(){varxhr=newXMLHttpRequest();//创建一个新的XMLHttpRequest对象xhr.open('GET','yourUrlPath',true);//配置请求，设置请求类型、URL和是否异步xhr.send();//发送请求}
    
                    
    • 
                    
  • 网上商城项目总结 续
                        猫只i
javaweb电子商城结构
                        
    前台1.用户登录注册邮箱验证校验用户名是否存在验证码自动登录2.导航条自定义标签库采用异步读取数据（使用gson将集合转换json数据）Redis服务器3.首页热门商品查询展示4.分类列表分页查询5.商品详情用cookie实现浏览记录6.购物车实现商品添加到购物车商品的查询，添加，修改，删除清空购物车7.提交订单添加订单（订单详情）确认订单（易宝支付）8.我的订单9.Fliter定义权限拦截（提交
    
                    
    • 
                    
  • 10个高效的Python爬虫框架，你用过几个？
                        进击的C语言
python
                        
    小型爬虫需求，requests库+bs4库就能解决；大型爬虫数据，尤其涉及异步抓取、内容管理及后续扩展等功能时，就需要用到爬虫框架了。下面介绍了10个爬虫框架，大家可以学习使用！1.Scrapyscrapy官网：https://scrapy.org/scrapy中文文档：https://www.osgeo.cn/scrapy/intro/oScrapy是一个为了爬取网站数据，提取结构性数据而编写的
    
                    
    • 
                    
  • 使用 Python 和 Aria2 异步下载和解析磁力链接元数据教程
                        日入百万
python
                        
    磁力链接（MagnetLinks）是一种流行的用于共享文件的链接格式。与传统的种子文件不同，磁力链接直接包含文件的哈希值，使得用户无需下载种子文件就能开始下载文件。在这篇教程中，我们将介绍如何使用Python和Aria2异步下载和解析磁力链接的元数据，并提取出文件的详细信息。步骤一：准备工作在开始之前，请确保你已经安装了以下工具和库：1.**Aria2**：一个轻量级多协议和多源命令行下载工具。你
    
                    
    • 
                    
  • ajax 获取一步数据,ajax异步获取数据
                        可可子姐姐教英语
ajax获取一步数据
                        
    functioncreateXHR(){if(typeofXMLHttpRequest!="undefined"){returnnewXMLHttpRequest();}elseif(typeofActiveXObject!="undefined"){varversion=["MSXML2.XMLHttp.6.0","MSXML2.XMLHttp.3.0","MSXML2.XMLHttp"];fo
    
                    
    • 
                    
  • Java并发编程-AQS详解及案例实战（上篇）
                        猿与禅
Java技术栈源码分析javaAQS并发编程原理
                        
    文章目录AQS概述AQS的核心概念AQS的工作原理AQS的灵活性使用场景使用指南使用示例AQS的本质:为啥叫做异步队列同步器AQS的核心机制“异步队列”的含义“同步器”的含义总结加锁失败的时候如何借助AQS异步入队阻塞等待AQS的锁队列加锁失败时的处理流程异步入队的机制总结ReentractLock如何设置公平锁策略以及原理设置公平锁策略公平锁的运作原理尝试获取锁释放锁性能与公平性的权衡tryLo
    
                    
    • 
                    
  • ajax讲解
                        夜不眠，码三千
okhttp
                        
    1.AJAX概述1.1什么是ajaxAJAX（AsynchronousJavascriptAndXML）翻译成中文就是“异步Javascript和XML”。即使用Javascript语言与服务器进行异步交互，传输的数据为XML（当然，传输的数据不只是XML）。AJAX还有一个最大的特点就是，当服务器响应时，不用刷新整个浏览器页面，而是可以局部刷新。这一特点给用户的感受是在不知不觉中完成请求和响应过
    
                    
    • 
                                
  • mongodb3.03开启认证
                                    21jhf
mongodb
                                    
    下载了最新mongodb3.03版本，当使用--auth 参数命令行开启mongodb用户认证时遇到很多问题，现总结如下： 
（百度上搜到的基本都是老版本的，看到db.addUser的就是，请忽略） 
Windows下我做了一个bat文件，用来启动mongodb，命令行如下： 
mongod --dbpath db\data --port 27017 --directoryperdb --logp
    
                                
    • 
                                
  • 【Spark103】Task not serializable
                                    bit1129
Serializable
                                    
    Task not serializable是Spark开发过程最令人头疼的问题之一，这里记录下出现这个问题的两个实例，一个是自己遇到的，另一个是stackoverflow上看到。等有时间了再仔细探究出现Task not serialiazable的各种原因以及出现问题后如何快速定位问题的所在，至少目前阶段碰到此类问题，没有什么章法 
1. 
  
package spark.exampl
    
                                
    • 
                                
  • 你所熟知的 LRU(最近最少使用)
                                    dalan_123
java
                                    
    关于LRU这个名词在很多地方或听说，或使用，接下来看下lru缓存回收的实现 
1、大体的想法 
    a、查询出最近最晚使用的项 
    b、给最近的使用的项做标记 
通过使用链表就可以完成这两个操作，关于最近最少使用的项只需要返回链表的尾部；标记最近使用的项，只需要将该项移除并放置到头部，那么难点就出现 你如何能够快速在链表定位对应的该项？ 
这时候多
    
                                
    • 
                                
  • Javascript 跨域
                                    周凡杨
JavaScriptjsonp跨域cross-domain
                                    
      
                                 
    
                                
    • 
                                
  • linux下安装apache服务器
                                    g21121
apache
                                    
    安装apache  
下载windows版本apache，下载地址：http://httpd.apache.org/download.cgi 
   1.windows下安装apache   
Windows下安装apache比较简单，注意选择路径和端口即可，这里就不再赘述了。  2.linux下安装apache：  
下载之后上传到linux的相关目录，这里指定为/home/apach
    
                                
    • 
                                
  • FineReport的JS编辑框和URL地址栏语法简介
                                    老A不折腾
finereportweb报表报表软件语法总结
                                    
      JS编辑框： 
1.FineReport的js。 
作为一款BS产品，browser端的JavaScript是必不可少的。 
FineReport中的js是已经调用了finereport.js的。 
大家知道，预览报表时，报表servlet会将cpt模板转为html，在这个html的head头部中会引入FineReport的js，这个finereport.js中包含了许多内置的fun
    
                                
    • 
                                
  • 根据STATUS信息对MySQL进行优化
                                    墙头上一根草
status
                                    
    mysql  查看当前正在执行的操作，即正在执行的sql语句的方法为: 
     show processlist 命令 
  
mysql> show global status;可以列出MySQL服务器运行各种状态值，我个人较喜欢的用法是show status like '查询值%';一、慢查询mysql> show variab
    
                                
    • 
                                
  • 我的spring学习笔记7-Spring的Bean配置文件给Bean定义别名
                                    aijuans
Spring 3
                                    
    本文介绍如何给Spring的Bean配置文件的Bean定义别名？ 
 
原始的 
 
 
<bean id="business" class="onlyfun.caterpillar.device.Business">
    <property name="writer">
        <ref b
    
                                
    • 
                                
  • 高性能mysql 之 性能剖析
                                    annan211
性能mysqlmysql 性能剖析剖析
                                    
    

1 定义性能优化
  mysql服务器性能，此处定义为 响应时间。
  在解释性能优化之前，先来消除一个误解，很多人认为，性能优化就是降低cpu的利用率或者减少对资源的使用。
  这是一个陷阱。
  资源时用来消耗并用来工作的，所以有时候消耗更多的资源能够加快查询速度，保持cpu忙绿，这是必要的。很多时候发现
  编译进了新版本的InnoDB之后，cpu利用率上升的很厉害，这并不
    
                                
    • 
                                
  • 主外键和索引唯一性约束
                                    百合不是茶
索引唯一性约束主外键约束联机删除
                                    
    目标;第一步;创建两张表 用户表和文章表 
        第二步;发表文章 
  
  
  1,建表; 
    ---用户表 BlogUsers
    --userID唯一的
    --userName
    --pwd
    --sex
        

    create 
    
                                
    • 
                                
  • 线程的调度
                                    bijian1013
java多线程thread线程的调度java多线程
                                    
    1.       Java提供一个线程调度程序来监控程序中启动后进入可运行状态的所有线程。线程调度程序按照线程的优先级决定应调度哪些线程来执行。 
  
2.       多数线程的调度是抢占式的（即我想中断程序运行就中断，不需要和将被中断的程序协商） 
a) 
    
                                
    • 
                                
  • 查看日志常用命令
                                    bijian1013
linux命令unix
                                    
    一.日志查找方法，可以用通配符查某台主机上的所有服务器grep "关键字" /wls/applogs/custom-*/error.log 
  
二.查看日志常用命令1.grep '关键字' error.log：在error.log中搜索'关键字'2.grep -C10 '关键字' error.log：显示关键字前后10行记录3.grep '关键字' error.l
    
                                
    • 
                                
  • 【持久化框架MyBatis3一】MyBatis版HelloWorld
                                    bit1129
helloworld
                                    
    MyBatis这个系列的文章，主要参考《Java Persistence with MyBatis 3》。 
  样例数据 
本文以MySQL数据库为例，建立一个STUDENTS表，插入两条数据，然后进行单表的增删改查 
  
  
CREATE TABLE STUDENTS
(
stud_id int(11) NOT NULL AUTO_INCREMENT,

    
                                
    • 
                                
  • 【Hadoop十五】Hadoop Counter
                                    bit1129
hadoop
                                    
      
 1. 只有Map任务的Map Reduce Job  
	File System Counters
		FILE: Number of bytes read=3629530
		FILE: Number of bytes written=98312
		FILE: Number of read operations=0
		FILE: Number of lar
    
                                
    • 
                                
  • 解决Tomcat数据连接池无法释放
                                    ronin47
tomcat 连接池　优化
                                    
     
 近段时间，公司的检测中心报表系统(SMC)的开发人员时不时找到我，说用户老是出现无法登录的情况。前些日子因为手头上 有Jboss集群的测试工作，发现用户不能登录时，都是在Tomcat中将这个项目Reload一下就好了，不过只是治标而已，因为大概几个小时之后又会 再次出现无法登录的情况。 
  
今天上午，开发人员小毛又找到我，要我协助将这个问题根治一下，拖太久用户难保不投诉。 
简单分析了一
    
                                
    • 
                                
  • java-75-二叉树两结点的最低共同父结点
                                    bylijinnan
java
                                    
    
import java.util.LinkedList;
import java.util.List;

import ljn.help.*;
public class BTreeLowestParentOfTwoNodes {

	public static void main(String[] args) {
		/*
		 * node data is stored in
    
                                
    • 
                                
  • 行业垂直搜索引擎网页抓取项目
                                    carlwu
LuceneNutchHeritrixSolr
                                    
    公司有一个搜索引擎项目，希望各路高人有空来帮忙指导，谢谢！ 
这是详细需求： 
（1） 通过提供的网站地址(大概100-200个网站)，网页抓取程序能不断抓取网页和其它类型的文件（如Excel、PDF、Word、ppt及zip类型），并且程序能够根据事先提供的规则，过滤掉不相干的下载内容。 
（2） 程序能够搜索这些抓取的内容，并能对这些抓取文件按照油田名进行分类，然后放到服务器不同的目录中。 

    
                                
    • 
                                
  • [通讯与服务]在总带宽资源没有大幅增加之前,不适宜大幅度降低资费
                                    comsci
资源
                                    
     
 
      降低通讯服务资费，就意味着有更多的用户进入，就意味着通讯服务提供商要接待和服务更多的用户，在总体运维成本没有由于技术升级而大幅下降的情况下，这种降低资费的行为将导致每个用户的平均带宽不断下降，而享受到的服务质量也在下降，这对用户和服务商都是不利的。。。。。。。。 
 
 
    &nbs
    
                                
    • 
                                
  • Java时区转换及时间格式
                                    Cwind
java
                                    
    本文介绍Java API 中 Date, Calendar, TimeZone和DateFormat的使用，以及不同时区时间相互转化的方法和原理。 
  
问题描述： 
向处于不同时区的服务器发请求时需要考虑时区转换的问题。譬如，服务器位于东八区（北京时间，GMT+8:00），而身处东四区的用户想要查询当天的销售记录。则需把东四区的“今天”这个时间范围转换为服务器所在时区的时间范围。 

    
                                
    • 
                                
  • readonly,只读，不可用
                                    dashuaifu
jsjspdisablereadOnlyreadOnly
                                    
    readOnly 和 readonly 不同，在做js开发时一定要注意函数大小写和jsp黄线的警告！！！我就经历过这么一件事： 
使用readOnly在某些浏览器或同一浏览器不同版本有的可以实现“只读”功能，有的就不行，而且函数readOnly有黄线警告！！！就这样被折磨了不短时间！！！（期间使用过disable函数，但是发现disable函数之后后台接收不到前台的的数据！！！） 
  
    
                                
    • 
                                
  • LABjs、RequireJS、SeaJS 介绍
                                    dcj3sjt126com
jsWeb
                                    
    LABjs 的核心是 LAB（Loading and Blocking）：Loading 指异步并行加载，Blocking 是指同步等待执行。LABjs 通过优雅的语法（script 和 wait）实现了这两大特性，核心价值是性能优化。LABjs 是一个文件加载器。RequireJS 和 SeaJS 则是模块加载器，倡导的是一种模块化开发理念，核心价值是让 JavaScript 的模块化开发变得更
    
                                
    • 
                                
  • [应用结构]入口脚本
                                    dcj3sjt126com
PHPyii2
                                    
    入口脚本 
入口脚本是应用启动流程中的第一环，一个应用（不管是网页应用还是控制台应用）只有一个入口脚本。终端用户的请求通过入口脚本实例化应用并将将请求转发到应用。 
Web 应用的入口脚本必须放在终端用户能够访问的目录下，通常命名为 index.php，也可以使用 Web 服务器能定位到的其他名称。 
控制台应用的入口脚本一般在应用根目录下命名为 yii（后缀为.php），该文
    
                                
    • 
                                
  • haoop shell命令
                                    eksliang
hadoophadoop shell
                                    
     
 cat 
 chgrp 
 chmod 
 chown 
 copyFromLocal 
 copyToLocal 
 cp 
 du 
 dus 
 expunge 
 get 
 getmerge 
 ls 
 lsr 
 mkdir 
 movefromLocal 
 mv 
 put 
 rm 
 rmr 
 setrep 
 stat 
 tail 
 test 
 text 
 
    
                                
    • 
                                
  • MultiStateView不同的状态下显示不同的界面
                                    gundumw100
android
                                    
    只要将指定的view放在该控件里面，可以该view在不同的状态下显示不同的界面，这对ListView很有用，比如加载界面，空白界面，错误界面。而且这些见面由你指定布局，非常灵活。 
 
PS：ListView虽然可以设置一个EmptyView，但使用起来不方便，不灵活，有点累赘。 
 
 

<com.kennyc.view.MultiStateView xmlns:android=&qu
    
                                
    • 
                                
  • jQuery实现页面内锚点平滑跳转
                                    ini
JavaScripthtmljqueryhtml5css
                                    
    平时我们做导航滚动到内容都是通过锚点来做，刷的一下就直接跳到内容了，没有一丝的滚动效果，而且 url 链接最后会有“小尾巴”，就像#keleyi，今天我就介绍一款 jquery 做的滚动的特效，既可以设置滚动速度，又可以在 url 链接上没有“小尾巴”。 
  
效果体验：http://keleyi.com/keleyi/phtml/jqtexiao/37.htmHTML文件代码： 
&
    
                                
    • 
                                
  • kafka offset迁移
                                    kane_xie
kafka
                                    
    在早前的kafka版本中（0.8.0），offset是被存储在zookeeper中的。 
  
到当前版本（0.8.2）为止，kafka同时支持offset存储在zookeeper和offset manager（broker）中。 
  
从官方的说明来看，未来offset的zookeeper存储将会被弃用。因此现有的基于kafka的项目如果今后计划保持更新的话，可以考虑在合适
    
                                
    • 
                                
  • android > 搭建 cordova 环境
                                    mft8899
android
                                    
      
1 , 安装 node.js   
     http://nodejs.org 
     
node -v   查看版本 
  
2, 安装 npm 
  
可以先从  https://github.com/isaacs/npm/tags  下载 源码 解压到
    
                                
    • 
                                
  • java封装的比较器，比较是否全相同，获取不同字段名字
                                    qifeifei

                                    
     非常实用的java比较器，贴上代码： 
import java.util.HashSet;
import java.util.List;
import java.util.Set;

import net.sf.json.JSONArray;
import net.sf.json.JSONObject;
import net.sf.json.JsonConfig;

i
    
                                
    • 
                                
  • 记录一些函数用法
                                    .Aky.
位运算PHP数据库函数IP
                                    
    高手们照旧忽略。 
想弄个全天朝IP段数据库，找了个今天最新更新的国内所有运营商IP段，copy到文件，用文件函数，字符串函数把玩下。分割出startIp和endIp这样格式写入.txt文件，直接用phpmyadmin导入.csv文件的形式导入。（生命在于折腾，也许你们觉得我傻X，直接下载人家弄好的导入不就可以，做自己的菜鸟，让别人去说吧） 
 
当然用到了ip2long()函数把字符串转为整型数
    
                                
    • 
                                
  • sublime text 3 rust
                                    wudixiaotie
Sublime Text
                                    
    1.sublime text 3 => install package => Rust 
2.cd ~/.config/sublime-text-3/Packages 
3.mkdir rust 
4.git clone https://github.com/sp0/rust-style 
5.cd rust-style 
6.cargo build --release 
7.ctrl
    
                                
    •