{"id":1926,"date":"2024-06-19T12:16:06","date_gmt":"2024-06-19T12:16:06","guid":{"rendered":"https:\/\/www.w3computing.com\/articles\/?p=1926"},"modified":"2024-06-19T12:16:15","modified_gmt":"2024-06-19T12:16:15","slug":"javas-completablefuture-for-asynchronous-programming","status":"publish","type":"post","link":"https:\/\/www.w3computing.com\/articles\/javas-completablefuture-for-asynchronous-programming\/","title":{"rendered":"How to Use Java’s CompletableFuture for Asynchronous Programming"},"content":{"rendered":"\n

Asynchronous programming is crucial for developing responsive and efficient applications. In Java, the CompletableFuture<\/code> class introduced in Java 8 offers a powerful and flexible way to handle asynchronous programming. This tutorial aims to provide a comprehensive guide on how to use CompletableFuture<\/code> for non-beginners who are already familiar with Java but want to enhance their skills in asynchronous programming.<\/p>\n\n\n\n

1. Introduction to CompletableFuture<\/h2>\n\n\n\n

CompletableFuture<\/code> is part of the java.util.concurrent<\/code> package and provides a way to write non-blocking, asynchronous code. It represents a future result of an asynchronous computation, allowing you to attach callbacks that will be executed upon its completion.<\/p>\n\n\n\n

Key Features<\/h3>\n\n\n\n
    \n
  • Non-blocking<\/strong>: CompletableFuture<\/code> provides methods to attach callbacks that get executed without blocking the main thread.<\/li>\n\n\n\n
  • Composability<\/strong>: It allows combining multiple futures in various ways, such as running them in parallel or chaining them sequentially.<\/li>\n\n\n\n
  • Exception Handling<\/strong>: It provides mechanisms to handle exceptions gracefully in asynchronous workflows.<\/li>\n<\/ul>\n\n\n\n

    2. Creating a CompletableFuture<\/h2>\n\n\n\n

    Basic Creation and Completion<\/h3>\n\n\n\n

    You can create a CompletableFuture<\/code> instance using its static factory methods or directly through its constructor. Here are some common ways to create and complete a CompletableFuture<\/code>.<\/p>\n\n\n

    import<\/span> java.util.concurrent.CompletableFuture;\n\npublic<\/span> class<\/span> CompletableFutureExample<\/span> <\/span>{\n    public<\/span> static<\/span> void<\/span> main<\/span>(String[] args)<\/span> <\/span>{\n        \/\/ Creating a CompletableFuture<\/span>\n        CompletableFuture<String> future = new<\/span> CompletableFuture<>();\n\n        \/\/ Completing a CompletableFuture manually<\/span>\n        future.complete(\"Hello, World!\"<\/span>);\n\n        \/\/ Printing the result<\/span>\n        future.thenAccept(result -> System.out.println(result));\n    }\n}<\/code><\/span>Code language:<\/span> Java<\/span> (<\/span>java<\/span>)<\/span><\/small><\/pre>\n\n\n
    Using Static Factory Methods<\/h3>\n\n\n\n
    CompletableFuture<\/code> provides several static methods to create pre-completed futures or futures that complete asynchronously.<\/p>\n\n\n
    import<\/span> java.util.concurrent.CompletableFuture;\n\npublic<\/span> class<\/span> CompletableFutureExample<\/span> <\/span>{\n    public<\/span> static<\/span> void<\/span> main<\/span>(String[] args)<\/span> <\/span>{\n        \/\/ Creating a completed future<\/span>\n        CompletableFuture<String> completedFuture = CompletableFuture.completedFuture(\"Hello, World!\"<\/span>);\n        completedFuture.thenAccept(System.out::println);\n\n        \/\/ Running a task asynchronously<\/span>\n        CompletableFuture<Void> asyncFuture = CompletableFuture.runAsync(() -> {\n            \/\/ Simulate a long-running task<\/span>\n            try<\/span> {\n                Thread.sleep(1000<\/span>);\n            } catch<\/span> (InterruptedException e) {\n                e.printStackTrace();\n            }\n            System.out.println(\"Task completed\"<\/span>);\n        });\n\n        \/\/ Waiting for the async task to complete<\/span>\n        asyncFuture.join();\n    }\n}<\/code><\/span>Code language:<\/span> Java<\/span> (<\/span>java<\/span>)<\/span><\/small><\/pre>\n\n\n
    3. Combining Multiple CompletableFutures<\/h2>\n\n\n\n
    Chaining Futures<\/h3>\n\n\n\n
    One of the powerful features of CompletableFuture<\/code> is the ability to chain multiple futures together.<\/p>\n\n\n
    import<\/span> java.util.concurrent.CompletableFuture;\n\npublic<\/span> class<\/span> CompletableFutureChainingExample<\/span> <\/span>{\n    public<\/span> static<\/span> void<\/span> main<\/span>(String[] args)<\/span> <\/span>{\n        CompletableFuture.supplyAsync(() -> \"Hello\"<\/span>)\n                .thenApply(result -> result + \", World!\"<\/span>)\n                .thenAccept(System.out::println);\n    }\n}<\/code><\/span>Code language:<\/span> Java<\/span> (<\/span>java<\/span>)<\/span><\/small><\/pre>\n\n\n
    Combining Futures<\/h3>\n\n\n\n
    You can combine multiple futures using methods like thenCombine<\/code>, thenCompose<\/code>, and allOf<\/code>.<\/p>\n\n\n
    import<\/span> java.util.concurrent.CompletableFuture;\n\npublic<\/span> class<\/span> CompletableFutureCombiningExample<\/span> <\/span>{\n    public<\/span> static<\/span> void<\/span> main<\/span>(String[] args)<\/span> <\/span>{\n        CompletableFuture<String> future1 = CompletableFuture.supplyAsync(() -> \"Hello\"<\/span>);\n        CompletableFuture<String> future2 = CompletableFuture.supplyAsync(() -> \"World\"<\/span>);\n\n        \/\/ Combining results of two futures<\/span>\n        CompletableFuture<String> combinedFuture = future1.thenCombine(future2, (result1, result2) -> result1 + \" \"<\/span> + result2);\n\n        combinedFuture.thenAccept(System.out::println);\n    }\n}<\/code><\/span>Code language:<\/span> Java<\/span> (<\/span>java<\/span>)<\/span><\/small><\/pre>\n\n\n
    Waiting for All Futures<\/h3>\n\n\n\n
    If you need to wait for multiple futures to complete, you can use allOf<\/code>.<\/p>\n\n\n
    import<\/span> java.util.concurrent.CompletableFuture;\n\npublic<\/span> class<\/span> CompletableFutureAllOfExample<\/span> <\/span>{\n    public<\/span> static<\/span> void<\/span> main<\/span>(String[] args)<\/span> <\/span>{\n        CompletableFuture<String> future1 = CompletableFuture.supplyAsync(() -> \"Task 1\"<\/span>);\n        CompletableFuture<String> future2 = CompletableFuture.supplyAsync(() -> \"Task 2\"<\/span>);\n        CompletableFuture<String> future3 = CompletableFuture.supplyAsync(() -> \"Task 3\"<\/span>);\n\n        CompletableFuture<Void> allOf = CompletableFuture.allOf(future1, future2, future3);\n\n        allOf.thenRun(() -> {\n            System.out.println(\"All tasks completed\"<\/span>);\n        }).join();\n    }\n}<\/code><\/span>Code language:<\/span> Java<\/span> (<\/span>java<\/span>)<\/span><\/small><\/pre>\n\n\n
    Handling Any Completed Future<\/h3>\n\n\n\n
    You can also wait for any one of the futures to complete using anyOf<\/code>.<\/p>\n\n\n
    import<\/span> java.util.concurrent.CompletableFuture;\n\npublic<\/span> class<\/span> CompletableFutureAnyOfExample<\/span> <\/span>{\n    public<\/span> static<\/span> void<\/span> main<\/span>(String[] args)<\/span> <\/span>{\n        CompletableFuture<String> future1 = CompletableFuture.supplyAsync(() -> \"Task 1\"<\/span>);\n        CompletableFuture<String> future2 = CompletableFuture.supplyAsync(() -> \"Task 2\"<\/span>);\n        CompletableFuture<String> future3 = CompletableFuture.supplyAsync(() -> \"Task 3\"<\/span>);\n\n        CompletableFuture<Object> anyOf = CompletableFuture.anyOf(future1, future2, future3);\n\n        anyOf.thenAccept(result -> {\n            System.out.println(\"First completed task: \"<\/span> + result);\n        }).join();\n    }\n}<\/code><\/span>Code language:<\/span> Java<\/span> (<\/span>java<\/span>)<\/span><\/small><\/pre>\n\n\n
    4. Handling Exceptions<\/h2>\n\n\n\n
    Exception handling is an essential aspect of asynchronous programming. CompletableFuture<\/code> provides methods to handle exceptions gracefully.<\/p>\n\n\n\n
    Handling Exceptions with exceptionally<\/h3>\n\n\n\n
    You can use the exceptionally<\/code> method to provide a fallback value in case of an exception.<\/p>\n\n\n
    import<\/span> java.util.concurrent.CompletableFuture;\n\npublic<\/span> class<\/span> CompletableFutureExceptionallyExample<\/span> <\/span>{\n    public<\/span> static<\/span> void<\/span> main<\/span>(String[] args)<\/span> <\/span>{\n        CompletableFuture<String> future = CompletableFuture.supplyAsync(() -> {\n            if<\/span> (true<\/span>) {\n                throw<\/span> new<\/span> RuntimeException(\"Something went wrong\"<\/span>);\n            }\n            return<\/span> \"Hello, World!\"<\/span>;\n        });\n\n        future.exceptionally(ex -> {\n            System.err.println(\"Exception: \"<\/span> + ex.getMessage());\n            return<\/span> \"Fallback value\"<\/span>;\n        }).thenAccept(System.out::println);\n    }\n}<\/code><\/span>Code language:<\/span> Java<\/span> (<\/span>java<\/span>)<\/span><\/small><\/pre>\n\n\n
    Handling Exceptions with handle<\/h3>\n\n\n\n
    The handle<\/code> method allows you to process the result and handle the exception in one place.<\/p>\n\n\n
    import<\/span> java.util.concurrent.CompletableFuture;\n\npublic<\/span> class<\/span> CompletableFutureHandleExample<\/span> <\/span>{\n    public<\/span> static<\/span> void<\/span> main<\/span>(String[] args)<\/span> <\/span>{\n        CompletableFuture<String> future = CompletableFuture.supplyAsync(() -> {\n            if<\/span> (true<\/span>) {\n                throw<\/span> new<\/span> RuntimeException(\"Something went wrong\"<\/span>);\n            }\n            return<\/span> \"Hello, World!\"<\/span>;\n        });\n\n        future.handle((result, ex) -> {\n            if<\/span> (ex != null<\/span>) {\n                System.err.println(\"Exception: \"<\/span> + ex.getMessage());\n                return<\/span> \"Fallback value\"<\/span>;\n            }\n            return<\/span> result;\n        }).thenAccept(System.out::println);\n    }\n}<\/code><\/span>Code language:<\/span> Java<\/span> (<\/span>java<\/span>)<\/span><\/small><\/pre>\n\n\n
    Combining Exception Handling and Chaining<\/h3>\n\n\n\n
    You can combine exception handling with chaining to create robust asynchronous workflows.<\/p>\n\n\n
    import<\/span> java.util.concurrent.CompletableFuture;\n\npublic<\/span> class<\/span> CompletableFutureExceptionHandlingExample<\/span> <\/span>{\n    public<\/span> static<\/span> void<\/span> main<\/span>(String[] args)<\/span> <\/span>{\n        CompletableFuture.supplyAsync(() -> {\n            if<\/span> (true<\/span>) {\n                throw<\/span> new<\/span> RuntimeException(\"Something went wrong\"<\/span>);\n            }\n            return<\/span> \"Hello\"<\/span>;\n        })\n        .exceptionally(ex -> {\n            System.err.println(\"Exception: \"<\/span> + ex.getMessage());\n            return<\/span> \"Fallback value\"<\/span>;\n        })\n        .thenApply(result -> result + \", World!\"<\/span>)\n        .thenAccept(System.out::println);\n    }\n}<\/code><\/span>Code language:<\/span> Java<\/span> (<\/span>java<\/span>)<\/span><\/small><\/pre>\n\n\n
    5. Using CompletableFuture with Streams<\/h2>\n\n\n\n
    Java Streams and CompletableFuture<\/code> can be combined to process collections of asynchronous tasks efficiently.<\/p>\n\n\n\n
    Transforming a List of Futures<\/h3>\n\n\n\n
    You can transform a list of futures into a future of a list using the allOf<\/code> method.<\/p>\n\n\n
    import<\/span> java.util.List;\nimport<\/span> java.util.concurrent.CompletableFuture;\nimport<\/span> java.util.stream.Collectors;\nimport<\/span> java.util.stream.IntStream;\n\npublic<\/span> class<\/span> CompletableFutureStreamExample<\/span> <\/span>{\n    public<\/span> static<\/span> void<\/span> main<\/span>(String[] args)<\/span> <\/span>{\n        List<CompletableFuture<String>> futures = IntStream.range(1<\/span>, 6<\/span>)\n                .mapToObj(i -> CompletableFuture.supplyAsync(() -> \"Task \"<\/span> + i))\n                .collect(Collectors.toList());\n\n        CompletableFuture<Void> allOf = CompletableFuture.allOf(futures.toArray(new<\/span> CompletableFuture[0<\/span>]));\n\n        CompletableFuture<List<String>> allFutures = allOf.thenApply(v -> \n            futures.stream()\n                .map(CompletableFuture::join)\n                .collect(Collectors.toList())\n        );\n\n        allFutures.thenAccept(results -> {\n            results.forEach(System.out::println);\n        }).join();\n    }\n}<\/code><\/span>Code language:<\/span> Java<\/span> (<\/span>java<\/span>)<\/span><\/small><\/pre>\n\n\n
    Parallel Processing with Streams<\/h3>\n\n\n\n
    You can use parallel streams to initiate multiple asynchronous tasks in parallel.<\/p>\n\n\n
    import<\/span> java.util.concurrent.CompletableFuture;\nimport<\/span> java.util.stream.Collectors;\nimport<\/span> java.util.stream.IntStream;\n\npublic<\/span> class<\/span> CompletableFutureParallelStreamExample<\/span> <\/span>{\n    public<\/span> static<\/span> void<\/span> main<\/span>(String[] args)<\/span> <\/span>{\n        CompletableFuture[] futures = IntStream.range(1<\/span>, 6<\/span>)\n                .parallel()\n                .mapToObj(i -> CompletableFuture.runAsync(() -> {\n                    try<\/span> {\n                        Thread.sleep(1000<\/span>);\n                    } catch<\/span> (InterruptedException e) {\n                        e.printStackTrace();\n                    }\n                    System.out.println(\"Task \"<\/span> + i + \" completed\"<\/span>);\n                }))\n                .toArray(CompletableFuture[]::new<\/span>);\n\n        CompletableFuture.allOf(futures).join();\n    }\n}<\/code><\/span>Code language:<\/span> Java<\/span> (<\/span>java<\/span>)<\/span><\/small><\/pre>\n\n\n
    6. Real-world Examples<\/h2>\n\n\n\n
    Example 1: Fetching Data from Multiple APIs<\/h3>\n\n\n\n
    Imagine you need to fetch data from multiple APIs and combine the results. CompletableFuture<\/code> makes this task straightforward.<\/p>\n\n\n
    import<\/span> java.util.concurrent.CompletableFuture;\n\npublic<\/span> class<\/span> FetchDataExample<\/span> <\/span>{\n    public<\/span> static<\/span> void<\/span> main<\/span>(String[] args)<\/span> <\/span>{\n        CompletableFuture<String> api1 = CompletableFuture.supplyAsync(() -> fetchFromAPI1());\n        CompletableFuture<String> api2 = CompletableFuture.supplyAsync(() -> fetchFromAPI2());\n        CompletableFuture<String> api3 = CompletableFuture.supplyAsync(() -> fetchFromAPI3());\n\n        CompletableFuture<Void> allOf = CompletableFuture.allOf(api1, api2, api3);\n\n        allOf.thenRun(() -> {\n            String result1 = api1.join();\n            String result2 = api2.join();\n            String result3 = api3.join();\n\n            String combinedResult = result1 + \", \"<\/span> + result2 + \", \"<\/span> + result3;\n            System.out.println(\"Combined Result: \"<\/span> + combinedResult);\n        }).join();\n    }\n\n    private<\/span> static<\/span> String fetchFromAPI1<\/span>()<\/span> <\/span>{\n        \/\/ Simulate API call<\/span>\n        try<\/span> {\n            Thread.sleep(1000<\/span>);\n        } catch<\/span> (InterruptedException e) {\n            e.printStackTrace();\n        }\n        return<\/span> \"Data from API 1\"<\/span>;\n    }\n\n    private<\/span> static<\/span> String fetchFromAPI2<\/span>()<\/span> <\/span>{\n        \/\/ Simulate API call<\/span>\n        try<\/span> {\n            Thread.sleep(1000<\/span>);\n        } catch<\/span> (InterruptedException e) {\n            e.printStackTrace();\n        }\n        return<\/span> \"Data from API 2\"<\/span>;\n    }\n\n    private<\/span> static<\/span> String fetchFromAPI3<\/span>()<\/span> <\/span>{\n        \/\/ Simulate API call<\/span>\n        try<\/span> {\n            Thread.sleep(1000<\/span>);\n        } catch<\/span> (InterruptedException e) {\n            e.printStackTrace();\n        }\n        return<\/span> \"Data from API 3\"<\/span>;\n    }\n}<\/code><\/span>Code language:<\/span> Java<\/span> (<\/span>java<\/span>)<\/span><\/small><\/pre>\n\n\n
    Example 2: Processing a Batch of Tasks<\/h3>\n\n\n\n
    Suppose you need to process a batch of tasks in parallel and collect their results.<\/p>\n\n\n
    import<\/span> java.util.List;\nimport<\/span> java.util.concurrent.CompletableFuture;\nimport<\/span> java.util.stream.Collectors;\nimport<\/span> java.util.stream.IntStream;\n\npublic<\/span> class<\/span> BatchProcessingExample<\/span> <\/span>{\n    public<\/span> static<\/span> void<\/span> main<\/span>(String[] args)<\/span> <\/span>{\n        List<CompletableFuture<String>> futures = IntStream.range(1<\/span>, 11<\/span>)\n                .mapToObj(i -> CompletableFuture.supplyAsync(() -> processTask(i)))\n                .collect(Collectors.toList());\n\n        CompletableFuture<Void> allOf = CompletableFuture.allOf(futures.toArray(new<\/span> CompletableFuture[0<\/span>]));\n\n        CompletableFuture<List<String>> allFutures = allOf.thenApply(v -> \n            futures.stream()\n                .map(CompletableFuture::join)\n                .collect(Collectors.toList())\n        );\n\n        allFutures.thenAccept(results -> {\n            results.forEach(System.out::println);\n        }).join();\n    }\n\n    private<\/span> static<\/span> String processTask<\/span>(int<\/span> i)<\/span> <\/span>{\n        \/\/ Simulate a long-running task<\/span>\n        try<\/span> {\n            Thread.sleep(1000<\/span>);\n        } catch<\/span> (InterruptedException e) {\n            e.printStackTrace();\n        }\n        return<\/span> \"Task \"<\/span> + i + \" completed\"<\/span>;\n    }\n}<\/code><\/span>Code language:<\/span> Java<\/span> (<\/span>java<\/span>)<\/span><\/small><\/pre>\n\n\n
    7. Best Practices<\/h2>\n\n\n\n
    Avoid Blocking Calls<\/h3>\n\n\n\n
    Avoid blocking calls like join<\/code> or get<\/code> inside the CompletableFuture<\/code> chain. Instead, use asynchronous methods and callbacks.<\/p>\n\n\n\n
    Use Executor for Custom Thread Pools<\/h3>\n\n\n\n
    By default, CompletableFuture<\/code> uses the ForkJoinPool.commonPool() for async tasks. For better control, provide a custom executor.<\/p>\n\n\n
    import<\/span> java.util.concurrent.CompletableFuture;\nimport<\/span> java.util.concurrent.ExecutorService;\nimport<\/span> java.util.concurrent.Executors;\n\npublic<\/span> class<\/span> CustomExecutorExample<\/span> <\/span>{\n    public<\/span> static<\/span> void<\/span> main<\/span>(String[] args)<\/span> <\/span>{\n        ExecutorService executor = Executors.newFixedThreadPool(10<\/span>);\n\n        CompletableFuture<Void> future = CompletableFuture.runAsync(() -> {\n            \/\/ Task logic here<\/span>\n            System.out.println(\"Task running in custom executor\"<\/span>);\n        }, executor);\n\n        future.join();\n        executor.shutdown();\n    }\n}<\/code><\/span>Code language:<\/span> Java<\/span> (<\/span>java<\/span>)<\/span><\/small><\/pre>\n\n\n
    Handle Exceptions Properly<\/h3>\n\n\n\n
    Ensure to handle exceptions at every stage of the CompletableFuture<\/code> chain to avoid unexpected behavior.<\/p>\n\n\n\n
    Use Completion Stages<\/h3>\n\n\n\n
    Completion stages like thenApplyAsync<\/code>, thenAcceptAsync<\/code>, and thenRunAsync<\/code> allow you to offload work to a different thread pool.<\/p>\n\n\n\n
    Keep Chains Short and Simple<\/h3>\n\n\n\n
    Long chains of CompletableFuture<\/code> can become difficult to read and maintain. Break them into smaller, manageable pieces.<\/p>\n\n\n\n
    8. Conclusion<\/h2>\n\n\n\n
    CompletableFuture<\/code> is a versatile and powerful tool for asynchronous programming in Java. It allows you to write non-blocking, efficient, and scalable code by providing a rich API for composing and combining asynchronous tasks. By following best practices and understanding how to handle exceptions and combine futures, you can leverage CompletableFuture<\/code> to build robust and responsive applications.<\/p>\n\n\n\n
    This tutorial has covered the basics of creating, combining, and handling exceptions with CompletableFuture<\/code>, along with practical examples and best practices. With this knowledge, you can confidently implement asynchronous programming in your Java projects, improving performance and responsiveness.<\/p>\n","protected":false},"excerpt":{"rendered":"
    Asynchronous programming is crucial for developing responsive and efficient applications. In Java, the CompletableFuture class introduced in Java 8 offers a powerful and flexible way to handle asynchronous programming. This tutorial aims to provide a comprehensive guide on how to use CompletableFuture for non-beginners who are already familiar with Java but want to enhance their […]<\/p>\n","protected":false},"author":1,"featured_media":0,"comment_status":"closed","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"_genesis_hide_title":false,"_genesis_hide_breadcrumbs":false,"_genesis_hide_singular_image":false,"_genesis_hide_footer_widgets":false,"_genesis_custom_body_class":"","_genesis_custom_post_class":"","_genesis_layout":"","_jetpack_memberships_contains_paid_content":false,"footnotes":""},"categories":[5,4],"tags":[],"class_list":["post-1926","post","type-post","status-publish","format-standard","category-java","category-programming-languages","entry"],"yoast_head":"\nUsing Java's CompletableFuture for Asynchronous Programming<\/title>\n<meta name=\"description\" content=\"In Java, the CompletableFuture class introduced in Java 8 offers a powerful and flexible way to handle asynchronous programming.\" \/>\n<meta name=\"robots\" content=\"index, follow, max-snippet:-1, max-image-preview:large, max-video-preview:-1\" \/>\n<link rel=\"canonical\" href=\"https:\/\/www.w3computing.com\/articles\/javas-completablefuture-for-asynchronous-programming\/\" \/>\n<meta property=\"og:locale\" content=\"en_US\" \/>\n<meta property=\"og:type\" content=\"article\" \/>\n<meta property=\"og:title\" content=\"Using Java's CompletableFuture for Asynchronous Programming\" \/>\n<meta property=\"og:description\" content=\"In Java, the CompletableFuture class introduced in Java 8 offers a powerful and flexible way to handle asynchronous programming.\" \/>\n<meta property=\"og:url\" content=\"https:\/\/www.w3computing.com\/articles\/javas-completablefuture-for-asynchronous-programming\/\" \/>\n<meta property=\"article:published_time\" content=\"2024-06-19T12:16:06+00:00\" \/>\n<meta property=\"article:modified_time\" content=\"2024-06-19T12:16:15+00:00\" \/>\n<meta name=\"author\" content=\"w3compadmin\" \/>\n<meta name=\"twitter:card\" content=\"summary_large_image\" \/>\n<meta name=\"twitter:label1\" content=\"Written by\" \/>\n\t<meta name=\"twitter:data1\" content=\"w3compadmin\" \/>\n\t<meta name=\"twitter:label2\" content=\"Est. reading time\" \/>\n\t<meta name=\"twitter:data2\" content=\"3 minutes\" \/>\n<script type=\"application\/ld+json\" class=\"yoast-schema-graph\">{\"@context\":\"https:\\\/\\\/schema.org\",\"@graph\":[{\"@type\":\"TechArticle\",\"@id\":\"https:\\\/\\\/www.w3computing.com\\\/articles\\\/javas-completablefuture-for-asynchronous-programming\\\/#article\",\"isPartOf\":{\"@id\":\"https:\\\/\\\/www.w3computing.com\\\/articles\\\/javas-completablefuture-for-asynchronous-programming\\\/\"},\"author\":{\"name\":\"w3compadmin\",\"@id\":\"https:\\\/\\\/www.w3computing.com\\\/articles\\\/#\\\/schema\\\/person\\\/a550b3e20d78bb4f79b7c6b7b53f0561\"},\"headline\":\"How to Use Java’s CompletableFuture for Asynchronous Programming\",\"datePublished\":\"2024-06-19T12:16:06+00:00\",\"dateModified\":\"2024-06-19T12:16:15+00:00\",\"mainEntityOfPage\":{\"@id\":\"https:\\\/\\\/www.w3computing.com\\\/articles\\\/javas-completablefuture-for-asynchronous-programming\\\/\"},\"wordCount\":623,\"articleSection\":[\"Java\",\"Programming Languages\"],\"inLanguage\":\"en-US\"},{\"@type\":\"WebPage\",\"@id\":\"https:\\\/\\\/www.w3computing.com\\\/articles\\\/javas-completablefuture-for-asynchronous-programming\\\/\",\"url\":\"https:\\\/\\\/www.w3computing.com\\\/articles\\\/javas-completablefuture-for-asynchronous-programming\\\/\",\"name\":\"Using Java's CompletableFuture for Asynchronous Programming\",\"isPartOf\":{\"@id\":\"https:\\\/\\\/www.w3computing.com\\\/articles\\\/#website\"},\"datePublished\":\"2024-06-19T12:16:06+00:00\",\"dateModified\":\"2024-06-19T12:16:15+00:00\",\"author\":{\"@id\":\"https:\\\/\\\/www.w3computing.com\\\/articles\\\/#\\\/schema\\\/person\\\/a550b3e20d78bb4f79b7c6b7b53f0561\"},\"description\":\"In Java, the CompletableFuture class introduced in Java 8 offers a powerful and flexible way to handle asynchronous programming.\",\"breadcrumb\":{\"@id\":\"https:\\\/\\\/www.w3computing.com\\\/articles\\\/javas-completablefuture-for-asynchronous-programming\\\/#breadcrumb\"},\"inLanguage\":\"en-US\",\"potentialAction\":[{\"@type\":\"ReadAction\",\"target\":[\"https:\\\/\\\/www.w3computing.com\\\/articles\\\/javas-completablefuture-for-asynchronous-programming\\\/\"]}]},{\"@type\":\"BreadcrumbList\",\"@id\":\"https:\\\/\\\/www.w3computing.com\\\/articles\\\/javas-completablefuture-for-asynchronous-programming\\\/#breadcrumb\",\"itemListElement\":[{\"@type\":\"ListItem\",\"position\":1,\"name\":\"Articles Home\",\"item\":\"https:\\\/\\\/www.w3computing.com\\\/articles\\\/\"},{\"@type\":\"ListItem\",\"position\":2,\"name\":\"Programming Languages\",\"item\":\"https:\\\/\\\/www.w3computing.com\\\/articles\\\/programming-languages\\\/\"},{\"@type\":\"ListItem\",\"position\":3,\"name\":\"How to Use Java’s CompletableFuture for Asynchronous Programming\"}]},{\"@type\":\"WebSite\",\"@id\":\"https:\\\/\\\/www.w3computing.com\\\/articles\\\/#website\",\"url\":\"https:\\\/\\\/www.w3computing.com\\\/articles\\\/\",\"name\":\"Developer Articles Hub\",\"description\":\"\",\"alternateName\":\"Developer Articles\",\"potentialAction\":[{\"@type\":\"SearchAction\",\"target\":{\"@type\":\"EntryPoint\",\"urlTemplate\":\"https:\\\/\\\/www.w3computing.com\\\/articles\\\/?s={search_term_string}\"},\"query-input\":{\"@type\":\"PropertyValueSpecification\",\"valueRequired\":true,\"valueName\":\"search_term_string\"}}],\"inLanguage\":\"en-US\"},{\"@type\":\"Person\",\"@id\":\"https:\\\/\\\/www.w3computing.com\\\/articles\\\/#\\\/schema\\\/person\\\/a550b3e20d78bb4f79b7c6b7b53f0561\",\"name\":\"w3compadmin\",\"image\":{\"@type\":\"ImageObject\",\"inLanguage\":\"en-US\",\"@id\":\"https:\\\/\\\/www.w3computing.com\\\/articles\\\/wp-content\\\/litespeed\\\/avatar\\\/bd481d404e42caa2763662a3bfe825f8.jpg?ver=1780141266\",\"url\":\"https:\\\/\\\/www.w3computing.com\\\/articles\\\/wp-content\\\/litespeed\\\/avatar\\\/bd481d404e42caa2763662a3bfe825f8.jpg?ver=1780141266\",\"contentUrl\":\"https:\\\/\\\/www.w3computing.com\\\/articles\\\/wp-content\\\/litespeed\\\/avatar\\\/bd481d404e42caa2763662a3bfe825f8.jpg?ver=1780141266\",\"caption\":\"w3compadmin\"},\"sameAs\":[\"http:\\\/\\\/w3computing.com\\\/articles\"]}]}<\/script>\n<!-- \/ Yoast SEO plugin. -->","yoast_head_json":{"title":"Using Java's CompletableFuture for Asynchronous Programming","description":"In Java, the CompletableFuture class introduced in Java 8 offers a powerful and flexible way to handle asynchronous programming.","robots":{"index":"index","follow":"follow","max-snippet":"max-snippet:-1","max-image-preview":"max-image-preview:large","max-video-preview":"max-video-preview:-1"},"canonical":"https:\/\/www.w3computing.com\/articles\/javas-completablefuture-for-asynchronous-programming\/","og_locale":"en_US","og_type":"article","og_title":"Using Java's CompletableFuture for Asynchronous Programming","og_description":"In Java, the CompletableFuture class introduced in Java 8 offers a powerful and flexible way to handle asynchronous programming.","og_url":"https:\/\/www.w3computing.com\/articles\/javas-completablefuture-for-asynchronous-programming\/","article_published_time":"2024-06-19T12:16:06+00:00","article_modified_time":"2024-06-19T12:16:15+00:00","author":"w3compadmin","twitter_card":"summary_large_image","twitter_misc":{"Written by":"w3compadmin","Est. reading time":"3 minutes"},"schema":{"@context":"https:\/\/schema.org","@graph":[{"@type":"TechArticle","@id":"https:\/\/www.w3computing.com\/articles\/javas-completablefuture-for-asynchronous-programming\/#article","isPartOf":{"@id":"https:\/\/www.w3computing.com\/articles\/javas-completablefuture-for-asynchronous-programming\/"},"author":{"name":"w3compadmin","@id":"https:\/\/www.w3computing.com\/articles\/#\/schema\/person\/a550b3e20d78bb4f79b7c6b7b53f0561"},"headline":"How to Use Java’s CompletableFuture for Asynchronous Programming","datePublished":"2024-06-19T12:16:06+00:00","dateModified":"2024-06-19T12:16:15+00:00","mainEntityOfPage":{"@id":"https:\/\/www.w3computing.com\/articles\/javas-completablefuture-for-asynchronous-programming\/"},"wordCount":623,"articleSection":["Java","Programming Languages"],"inLanguage":"en-US"},{"@type":"WebPage","@id":"https:\/\/www.w3computing.com\/articles\/javas-completablefuture-for-asynchronous-programming\/","url":"https:\/\/www.w3computing.com\/articles\/javas-completablefuture-for-asynchronous-programming\/","name":"Using Java's CompletableFuture for Asynchronous Programming","isPartOf":{"@id":"https:\/\/www.w3computing.com\/articles\/#website"},"datePublished":"2024-06-19T12:16:06+00:00","dateModified":"2024-06-19T12:16:15+00:00","author":{"@id":"https:\/\/www.w3computing.com\/articles\/#\/schema\/person\/a550b3e20d78bb4f79b7c6b7b53f0561"},"description":"In Java, the CompletableFuture class introduced in Java 8 offers a powerful and flexible way to handle asynchronous programming.","breadcrumb":{"@id":"https:\/\/www.w3computing.com\/articles\/javas-completablefuture-for-asynchronous-programming\/#breadcrumb"},"inLanguage":"en-US","potentialAction":[{"@type":"ReadAction","target":["https:\/\/www.w3computing.com\/articles\/javas-completablefuture-for-asynchronous-programming\/"]}]},{"@type":"BreadcrumbList","@id":"https:\/\/www.w3computing.com\/articles\/javas-completablefuture-for-asynchronous-programming\/#breadcrumb","itemListElement":[{"@type":"ListItem","position":1,"name":"Articles Home","item":"https:\/\/www.w3computing.com\/articles\/"},{"@type":"ListItem","position":2,"name":"Programming Languages","item":"https:\/\/www.w3computing.com\/articles\/programming-languages\/"},{"@type":"ListItem","position":3,"name":"How to Use Java’s CompletableFuture for Asynchronous Programming"}]},{"@type":"WebSite","@id":"https:\/\/www.w3computing.com\/articles\/#website","url":"https:\/\/www.w3computing.com\/articles\/","name":"Developer Articles Hub","description":"","alternateName":"Developer Articles","potentialAction":[{"@type":"SearchAction","target":{"@type":"EntryPoint","urlTemplate":"https:\/\/www.w3computing.com\/articles\/?s={search_term_string}"},"query-input":{"@type":"PropertyValueSpecification","valueRequired":true,"valueName":"search_term_string"}}],"inLanguage":"en-US"},{"@type":"Person","@id":"https:\/\/www.w3computing.com\/articles\/#\/schema\/person\/a550b3e20d78bb4f79b7c6b7b53f0561","name":"w3compadmin","image":{"@type":"ImageObject","inLanguage":"en-US","@id":"https:\/\/www.w3computing.com\/articles\/wp-content\/litespeed\/avatar\/bd481d404e42caa2763662a3bfe825f8.jpg?ver=1780141266","url":"https:\/\/www.w3computing.com\/articles\/wp-content\/litespeed\/avatar\/bd481d404e42caa2763662a3bfe825f8.jpg?ver=1780141266","contentUrl":"https:\/\/www.w3computing.com\/articles\/wp-content\/litespeed\/avatar\/bd481d404e42caa2763662a3bfe825f8.jpg?ver=1780141266","caption":"w3compadmin"},"sameAs":["http:\/\/w3computing.com\/articles"]}]}},"featured_image_src":null,"featured_image_src_square":null,"author_info":{"display_name":"w3compadmin","author_link":"https:\/\/www.w3computing.com\/articles\/author\/w3compadmin\/"},"jetpack_featured_media_url":"","jetpack_sharing_enabled":true,"_links":{"self":[{"href":"https:\/\/www.w3computing.com\/articles\/wp-json\/wp\/v2\/posts\/1926","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/www.w3computing.com\/articles\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/www.w3computing.com\/articles\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/www.w3computing.com\/articles\/wp-json\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/www.w3computing.com\/articles\/wp-json\/wp\/v2\/comments?post=1926"}],"version-history":[{"count":2,"href":"https:\/\/www.w3computing.com\/articles\/wp-json\/wp\/v2\/posts\/1926\/revisions"}],"predecessor-version":[{"id":1928,"href":"https:\/\/www.w3computing.com\/articles\/wp-json\/wp\/v2\/posts\/1926\/revisions\/1928"}],"wp:attachment":[{"href":"https:\/\/www.w3computing.com\/articles\/wp-json\/wp\/v2\/media?parent=1926"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.w3computing.com\/articles\/wp-json\/wp\/v2\/categories?post=1926"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.w3computing.com\/articles\/wp-json\/wp\/v2\/tags?post=1926"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}