연결·읽기 시간 제한

import java.net.Socket;

public final class ImplicitConnectTimeout {
    static Socket connect(String host, int port) throws Exception {
        return new Socket(host, port);
    }

    public static void main(String[] args) {
        System.out.println("운영체제 기본 connect 대기는 실행하지 않습니다");
    }
}

import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.net.InetSocketAddress;
import java.net.Socket;
import java.time.Duration;

public final class TimedSocketClient {
    static String request(InetSocketAddress endpoint, String message,
                          Duration connectTimeout, Duration readTimeout) throws Exception {
        try (var socket = new Socket()) {
            socket.connect(endpoint, Math.toIntExact(connectTimeout.toMillis()));
            socket.setSoTimeout(Math.toIntExact(readTimeout.toMillis()));
            try (var input = new DataInputStream(socket.getInputStream());
                 var output = new DataOutputStream(socket.getOutputStream())) {
                output.writeUTF(message);
                output.flush();
                return input.readUTF();
            }
        }
    }

    public static void main(String[] args) {
        InetSocketAddress endpoint = InetSocketAddress.createUnresolved("service.invalid", 443);
        System.out.println("configured=" + endpoint + " client uses explicit limits");
    }
}

import java.net.InetAddress;
import java.net.ServerSocket;
import java.net.Socket;
import java.net.SocketTimeoutException;

public final class ReadTimeoutProbe {
    public static void main(String[] args) throws Exception {
        try (var server = new ServerSocket(0, 1, InetAddress.getLoopbackAddress())) {
            Thread delayed = Thread.startVirtualThread(() -> {
                try (Socket accepted = server.accept()) {
                    Thread.sleep(250);
                    accepted.getOutputStream().write(1);
                } catch (Exception ignored) { }
            });

            try (var client = new Socket(InetAddress.getLoopbackAddress(), server.getLocalPort())) {
                client.setSoTimeout(50);
                try {
                    client.getInputStream().read();
                    System.out.println("unexpected byte");
                } catch (SocketTimeoutException expected) {
                    System.out.println("read timed out");
                }
            }
            delayed.join();
        }
    }
}

import java.time.Duration;
import java.util.concurrent.TimeUnit;

public final class RequestDeadline {
    private final long endNanos;

    RequestDeadline(Duration budget) {
        if (budget.isNegative() || budget.isZero()) throw new IllegalArgumentException("budget");
        endNanos = Math.addExact(System.nanoTime(), budget.toNanos());
    }

    int remainingMillis() throws java.net.SocketTimeoutException {
        long nanos = endNanos - System.nanoTime();
        if (nanos <= 0) throw new java.net.SocketTimeoutException("request deadline");
        long roundedUp = Math.max(1, TimeUnit.NANOSECONDS.toMillis(nanos));
        return Math.toIntExact(Math.min(roundedUp, Integer.MAX_VALUE));
    }

    public static void main(String[] args) throws Exception {
        RequestDeadline deadline = new RequestDeadline(Duration.ofSeconds(1));
        System.out.println("connectLimit=" + deadline.remainingMillis());
        System.out.println("readLimit=" + deadline.remainingMillis());
    }
}

import java.net.SocketTimeoutException;
import java.time.Duration;
import java.util.Objects;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicLong;
import java.util.function.LongSupplier;

public final class ElapsedRequestDeadline {
    private final long startedAt;
    private final long budgetNanos;
    private final LongSupplier ticks;

    ElapsedRequestDeadline(Duration budget) {
        this(budget, System::nanoTime);
    }

    ElapsedRequestDeadline(Duration budget, LongSupplier ticks) {
        if (budget.isNegative() || budget.isZero()) {
            throw new IllegalArgumentException("budget");
        }
        this.budgetNanos = budget.toNanos();
        this.ticks = Objects.requireNonNull(ticks);
        this.startedAt = ticks.getAsLong();
    }

    int remainingMillis() throws SocketTimeoutException {
        long elapsed = ticks.getAsLong() - startedAt;
        if (elapsed < 0 || elapsed >= budgetNanos) {
            throw new SocketTimeoutException("request deadline");
        }
        long remaining = budgetNanos - elapsed;
        long millis = Math.max(1, TimeUnit.NANOSECONDS.toMillis(remaining));
        return Math.toIntExact(Math.min(millis, Integer.MAX_VALUE));
    }

    public static void main(String[] args) throws Exception {
        long start = Long.MAX_VALUE - 5;
        try {
            Math.addExact(start, 10);
        } catch (ArithmeticException expected) {
            System.out.println("absolute addition overflow");
        }
        AtomicLong clock = new AtomicLong(start);
        var deadline = new ElapsedRequestDeadline(Duration.ofNanos(10), clock::get);
        clock.set(Long.MIN_VALUE + 1);
        System.out.println("elapsedNanos=" + (clock.get() - start));
        System.out.println("remainingMillis=" + deadline.remainingMillis());
        clock.set(Long.MIN_VALUE + 4);
        try {
            deadline.remainingMillis();
        } catch (SocketTimeoutException expected) {
            System.out.println("expired");
        }
    }
}

absolute addition overflow
elapsedNanos=7
remainingMillis=1
expired