theboreddev

        final ExecutorService executor = Executors.newSingleThreadExecutor();
        CompletableFuture.runAsync(task, executor);

theboreddev

        CompletableFuture<String> completableFuture = new CompletableFuture<>();

        completableFuture
                .thenAccept(System.out::println);

        completableFuture.complete("I have completed!");

theboreddev

        CompletableFuture<Void> chain = new CompletableFuture<>();

        chain.thenComposeAsync(nil -> createUser())
                .thenAcceptAsync(logNewUserId())
                .thenComposeAsync(nil ->
                        registerAddress()
                                .thenAcceptBothAsync(registerPaymentDetails(), (address, paymentDetailsSuccess) -> {
                                    System.out.println("Registered address was : " + address);
                                    System.out.println("Registered payment details success : " + paymentDetailsSuccess);
                                })

theboreddev

        CompletableFuture<Result> chain = CompletableFuture.runAsync(() -> System.out.println("Start"))
                .thenCombine(subTask, (nil, text) -> {
                    if (text == null || text.isEmpty())
                        throw new IllegalArgumentException("Text cannot be null or empty!");
                    return Result.COMPLETED;
                })
                .exceptionally(exception -> Result.FAILED);

theboreddev

        CompletableFuture<String> subTask = new CompletableFuture<>();

        CompletableFuture<Result> chain = CompletableFuture.runAsync(() -> System.out.println("Start"))
                .thenCombine(subTask, (nil, text) -> {
                    if (text == null || text.isEmpty())
                        throw new IllegalArgumentException("Text cannot be null or empty!");
                    return Result.COMPLETED;
                })
                .completeOnTimeout(Result.TIMEOUT, 500, TimeUnit.MILLISECONDS)
                .exceptionally(exception -> Result.FAILED);

theboreddev

package com.theboreddev.concurrency;

import com.theboreddev.Processor;

import java.util.List;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.concurrent.atomic.LongAccumulator;

theboreddev

public interface Processor {
    Integer process(List<Integer> input) throws InterruptedException;
}

theboreddev

package com.theboreddev.sequential;

import com.theboreddev.Processor;

import java.util.List;

public class SequentialProcessor implements Processor {

    @Override
    public Integer process(List<Integer> input) {

theboreddev

package com.theboreddev.parallelism;

import com.theboreddev.Processor;

import java.util.List;

public class ParallelProcessor implements Processor {

    @Override
    public Integer process(List<Integer> input) {

theboreddev

        final PriceCalculatorFactory factory = new PriceCalculatorFactory();
        
        final Item newItem = new Item(1L, new BigDecimal("12.99"));
        final DeliveryPriceCalculator priceCalculator = factory.priceCalculatorFor(OldStylePlan.BASIC);
        System.out.println("Delivery price is " + priceCalculator.priceFor(newItem));