java 41 lines · 8 steps

Enforcing HTTP timeouts with a Future

A thread pool runs each fetch off-thread so the caller can bound it with Future.get and cancel on timeout.

Explained by highlit

Intermediate concurrency timeouts thread-pool exception-handling cancellation

1public class TimedFetchService {
2 
  private final ExecutorService executor = Executors.newFixedThreadPool(8);
  private final HttpClient httpClient = HttpClient.newHttpClient();
5 
  public String fetchWithTimeout(URI uri, Duration timeout) {
      Future<String> future = executor.submit(() -> {
          HttpRequest request = HttpRequest.newBuilder(uri).GET().build();
          HttpResponse<String> response =
              httpClient.send(request, HttpResponse.BodyHandlers.ofString());
          return response.body();
      });
13 
      try {
          return future.get(timeout.toMillis(), TimeUnit.MILLISECONDS);
      } catch (TimeoutException e) {
          future.cancel(true);
          throw new FetchTimeoutException(
              "Request to " + uri + " exceeded " + timeout.toMillis() + "ms", e);
      } catch (ExecutionException e) {
          throw new FetchFailedException("Request to " + uri + " failed", e.getCause());
      } catch (InterruptedException e) {
          future.cancel(true);
          Thread.currentThread().interrupt();
          throw new FetchFailedException("Interrupted while fetching " + uri, e);
      }
  }
28 
  @PreDestroy
  public void shutdown() {
      executor.shutdown();
      try {
          if (!executor.awaitTermination(5, TimeUnit.SECONDS)) {
              executor.shutdownNow();
          }
      } catch (InterruptedException e) {
          executor.shutdownNow();
          Thread.currentThread().interrupt();
      }
  }
41}

01 / 01

STEP 01

Walkthrough

Space play ←→ step click any line

Three takeaways

1Wrapping blocking work in a Future lets you impose a wall-clock deadline the underlying call may not support.
2Each checked exception from Future.get maps to a distinct failure mode that deserves its own handling.
3A pooled executor needs an explicit lifecycle so its threads shut down cleanly with the owning component.

Related explainers

java

@Component
public class RefreshTokenSuccessHandler implements AuthenticationSuccessHandler {
 
    private final RefreshTokenService refreshTokenService;

Issuing JWT and refresh tokens on login in Spring

authentication jwt http-cookies

Intermediate 7 steps

java

import com.fasterxml.jackson.core.JsonGenerator;
import com.fasterxml.jackson.databind.JsonSerializer;
import com.fasterxml.jackson.databind.SerializerProvider;
import com.fasterxml.jackson.databind.module.SimpleModule;

Serializing Money to JSON in Spring

serialization jackson money

Intermediate 8 steps

javascript

import { unstable_cache, revalidateTag } from 'next/cache'
import { db } from '@/lib/db'
 
export const getDashboardStats = unstable_cache(

Caching dashboard stats in Next.js

caching cache-invalidation tag-based-revalidation

Intermediate 8 steps

java

@Component
@Order(Ordered.HIGHEST_PRECEDENCE)
public class TenantResolutionFilter extends OncePerRequestFilter {

How a tenant-resolution filter works in Spring

multi-tenancy servlet-filter thread-local

Intermediate 8 steps

java

@Repository
public interface SubscriptionRepository extends JpaRepository<Subscription, Long> {
 
    @Modifying(clearAutomatically = true, flushAutomatically = true)

Bulk JPQL updates in a Spring Data repository

jpql bulk-update modifying-query

Intermediate 5 steps

java

package com.example.uploads.config;
 
import jakarta.servlet.MultipartConfigElement;
import org.springframework.boot.web.servlet.MultipartConfigFactory;