Guava之ListenableFuture（链式回调）

妖狐艹你老母 2022-03-21 08:24 184阅读 0赞

package cn.dubby.listeningfuture;
    
    import com.google.common.util.concurrent.*;
    
    import java.util.concurrent.Callable;
    import java.util.concurrent.CountDownLatch;
    import java.util.concurrent.Executors;
    
    /**
     * Created by dubby on 16/4/29.
     */
    public class ListeningFutureDemo {
    
        public static void main(String[] args) {
            final CountDownLatch latch = new CountDownLatch(1);
            final ListeningExecutorService service = MoreExecutors.listeningDecorator(Executors.newFixedThreadPool(10));
    
            ListenableFuture<String> explosion = service.submit(new Callable<String>() {
                public String call() throws Exception {
                    System.out.println("任务线程正在执行...");
                    try {
                        Thread.sleep(1000);
                    } catch (Exception e) {
                        e.printStackTrace();
                    }
                    return "任务线程的结果";
                }
            });
    
            ListenableFuture<String> first = Futures.transform(explosion, new AsyncFunction<String, String>() {
                public ListenableFuture<String> apply(final String input) throws Exception {
                    ListenableFuture<String> temp = service.submit(new Callable<String>() {
                        public String call() throws Exception {
                            System.out.println("第1个回调线程正在执行...");
                            try {
                                Thread.sleep(1000);
                            } catch (Exception e) {
                                e.printStackTrace();
                            }
                            return input + " & 第1个回调线程的结果 ";
                        }
                    });
                    return temp;
                }
            }, service);
    
    
            ListenableFuture<String> second = Futures.transform(first, new AsyncFunction<String, String>() {
                public ListenableFuture<String> apply(final String input) throws Exception {
                    ListenableFuture<String> temp = service.submit(new Callable<String>() {
                        public String call() throws Exception {
                            System.out.println("第2个回调线程正在执行...");
                            try {
                                Thread.sleep(1000);
                            } catch (Exception e) {
                                e.printStackTrace();
                            }
                            return input + " & 第2个回调线程的结果 ";
                        }
                    });
                    return temp;
                }
            }, service);
    
            ListenableFuture<String> third = Futures.transform(second, new AsyncFunction<String, String>() {
                public ListenableFuture<String> apply(final String input) throws Exception {
                    ListenableFuture<String> temp = service.submit(new Callable<String>() {
                        public String call() throws Exception {
                            System.out.println("第3个回调线程正在执行...");
                            try {
                                Thread.sleep(1000);
                            } catch (Exception e) {
                                e.printStackTrace();
                            }
                            return input + " & 第3个回调线程的结果 ";
                        }
                    });
                    return temp;
                }
            }, service);
    
            ListenableFuture<String> forth = Futures.transform(third, new AsyncFunction<String, String>() {
                public ListenableFuture<String> apply(final String input) throws Exception {
                    ListenableFuture<String> temp = service.submit(new Callable<String>() {
                        public String call() throws Exception {
                            System.out.println("第4个回调线程正在执行...");
                            try {
                                Thread.sleep(1000);
                            } catch (Exception e) {
                                e.printStackTrace();
                            }
                            return input + " & 第4个回调线程的结果 ";
                        }
                    });
                    return temp;
                }
            }, service);
    
            Futures.addCallback(forth, new FutureCallback<String>() {
                public void onSuccess(String result) {
                    latch.countDown();
                    System.out.println("结果: " + result);
                }
    
                public void onFailure(Throwable t) {
                    System.out.println(t.getMessage());
                }
            });
            try {
                latch.await();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            service.shutdown();
        }
    
    }

--------------------

作者：无始之名  
来源：CSDN  
原文：[https://blog.csdn.net/u011499747/article/details/50997122][https_blog.csdn.net_u011499747_article_details_50997122]  
版权声明：本文为博主原创文章，转载请附上博文链接！

[https_blog.csdn.net_u011499747_article_details_50997122]: https://blog.csdn.net/u011499747/article/details/50997122