import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
public class ExecutorExample {
    public static void main(String[] args) {
        // Create a fixed thread pool with 5 threads
        ExecutorService executor = Executors.newFixedThreadPool(5);
        // Submit 10 tasks for execution
        for (int i = 0; i < 10; i++) {
            final int taskId = i;
            executor.submit(new Runnable() {
                @Override
                public void run() {
                    // Perform an API request here
                    // For example, using the OkHttp library:
                    // OkHttpClient client = new OkHttpClient();
                    // Request request = new Request.Builder()
                    //          .url("https://example.com/api/task" + taskId)
                    //          .build();
                    // Response response = client.newCall(request).execute();
                    // Do something with the response
                    System.out.println("Task " + taskId + " completed");
                }
            });
        }
        // Shut down the executor
        executor.shutdown();
    }
}

import java.io.IOException;
import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.SelectionKey;
import java.nio.channels.Selector;
import java.nio.channels.ServerSocketChannel;
import java.nio.channels.SocketChannel;
import java.util.Iterator;
public class NioServer {
    public static void main(String[] args) throws IOException {
        // Open a selector
        Selector selector = Selector.open();
        // Open a server socket channel
        ServerSocketChannel serverSocket = ServerSocketChannel.open();
        serverSocket.bind(new InetSocketAddress(8080));
        serverSocket.configureBlocking(false);
        // Register the server socket channel with the selector
        serverSocket.register(selector, SelectionKey.OP_ACCEPT);
        while (true) {
            // Wait for events
            selector.select();
            // Iterate over the events
            Iterator<SelectionKey> iterator = selector.selectedKeys().iterator();
            while (iterator.hasNext()) {
                SelectionKey key = iterator.next();
                // Handle a new connection
                if (key.isAcceptable()) {
                    ServerSocketChannel channel = (ServerSocketChannel) key.channel();
                    SocketChannel client = channel.accept();
                    client.configureBlocking(false);
                    client.register(selector, SelectionKey.OP_READ);
                }
                // Handle a read event
                if (key.isReadable()) {
                    SocketChannel client = (SocketChannel) key.channel();
                    ByteBuffer buffer = ByteBuffer.allocate(1024);
                    int read = client.read(buffer);
                    if (read > 0) {
                        buffer.flip();
                        String message = new String(buffer.array(), 0, read);
                        System.out.println("Received: " + message);
                    }
                }
                iterator.remove();
            }
        }
    }
}

import okhttp3.Call;
import okhttp3.Callback;
import okhttp3.OkHttpClient;
import okhttp3.Request;
import okhttp3.Response;
import java.io.IOException;
public class OkHttpAsyncExample {
    public static void main(String[] args) {
        OkHttpClient client = new OkHttpClient();
        Request request = new Request.Builder()
                .url("https://jsonplaceholder.typicode.com/todos/1")
                .build();
        client.newCall(request).enqueue(new Callback() {
            @Override
            public void onFailure(Call call, IOException e) {
                e.printStackTrace();
            }
            @Override
            public void onResponse(Call call, Response response) throws IOException {
                if (!response.isSuccessful()) {
                    throw new IOException("Unexpected code " + response);
                }
                String responseBody = response.body().string();
                System.out.println(responseBody);
            }
        });
    }
}

import retrofit2.Call;
import retrofit2.Callback;
import retrofit2.Response;
import retrofit2.Retrofit;
import retrofit2.converter.gson.GsonConverterFactory;
public class RetrofitAsyncExample {
    public static void main(String[] args) {
        Retrofit retrofit = new Retrofit.Builder()
                .baseUrl("https://jsonplaceholder.typicode.com/")
                .addConverterFactory(GsonConverterFactory.create())
                .build();
        JsonPlaceholderApi jsonPlaceholderApi = retrofit.create(JsonPlaceholderApi.class);
        Call<Todo> call = jsonPlaceholderApi.getTodo(1);
        call.enqueue(new Callback<Todo>() {
            @Override
            public void onResponse(Call<Todo> call, Response<Todo> response) {
                if (!response.isSuccessful()) {
                    System.out.println("Unexpected code " + response);
                    return;
                }
                Todo todo = response.body();
                System.out.println(todo);
            }
            @Override
            public void onFailure(Call<Todo> call, Throwable t) {
                t.printStackTrace();
            }
        });
    }
}
interface JsonPlaceholderApi {
    @GET("todos/{id}")
    Call<Todo> getTodo(@Path("id") int id);
}
class Todo {
    int userId;
    int id;
    String title;
    boolean completed;
    // getters and setters
}