Протокол — это формальный набор правил, определяющий формат, порядок и обработку данных при их передаче между устройствами. Протоколы работают на разных уровнях абстракции: от физического уровня (электрические сигналы в кабеле) до прикладного (HTTP, gRPC). В Java-разработке нас интересуют прежде всего транспортный и прикладной уровни модели TCP/IP.

TCP/IP — это стек протоколов, лежащий в основе интернета. Вместо семиуровневой модели OSI в инженерной практике используется упрощённая четырёхуровневая модель: канальный уровень (Ethernet, Wi-Fi), сетевой (IP), транспортный (TCP, UDP) и прикладной (HTTP, DNS, SSH).

import java.net.InetAddress;
import java.net.UnknownHostException;

public class IpExample {
    public static void main(String[] args) throws UnknownHostException {
        // Разрешение доменного имени в IP-адрес через DNS
        InetAddress address = InetAddress.getByName("www.example.com");
        System.out.println(address.getHostAddress());  // 93.184.216.34
        System.out.println(address instanceof java.net.Inet4Address);  // true
    }
}

InetAddress ipv6 = InetAddress.getByName("::1");  // loopback в IPv6
System.out.println(ipv6 instanceof java.net.Inet6Address);  // true

Loopback (петлевой адрес) — это специальный адрес, который всегда указывает на текущий хост. В IPv4 это 127.0.0.1, в IPv6 — ::1. Пакеты, отправленные на loopback, не выходят за пределы сетевого стека ОС и не попадают в физический интерфейс.

Маршрутизация (routing) — это процесс выбора пути для сетевого пакета от источника к получателю через промежуточные узлы (роутеры). Каждый роутер принимает решение на основе таблицы маршрутизации и заголовка IP-пакета.

Сокет (socket) — это абстракция, представляющая одну конечную точку сетевого соединения. В TCP сокет однозначно определяется четвёркой: IP-источника, порт-источника, IP-назначения, порт-назначения. В Java сокет представлен классами java.net.Socket (клиент) и java.net.ServerSocket (сервер).

Эфемерный порт (ephemeral port) — это временный порт, автоматически выделяемый стеком TCP/IP операционной системы для исходящего соединения. После закрытия соединения порт переходит в состояние TIME_WAIT и освобождается через несколько минут.

import java.net.InetSocketAddress;

// InetSocketAddress объединяет IP-адрес и порт
InetSocketAddress serverAddr = new InetSocketAddress("192.168.1.100", 8080);
InetSocketAddress localAddr = new InetSocketAddress("0.0.0.0", 0);  // порт 0 = эфемерный

Флаг в контексте TCP — это битовое поле в заголовке сегмента, управляющее поведением протокола. Флаги: SYN (начало соединения), ACK (подтверждение), FIN (завершение), RST (сброс), PSH (немедленная передача данных приложению), URG (срочные данные).

// Псевдокод трёхэтапного рукопожатия на уровне сокетов Java
// На самом деле это происходит внутри ядра ОС, Java лишь инициирует

// Клиент
Socket clientSocket = new Socket();
clientSocket.connect(serverAddress);  // Внутри ядра: отправка SYN -> получение SYN-ACK -> отправка ACK

// Сервер
ServerSocket serverSocket = new ServerSocket(8080);
Socket acceptedSocket = serverSocket.accept();  // Внутри ядра: получение SYN -> отправка SYN-ACK -> получение ACK

Датаграмма (datagram) — это самостоятельная единица данных, передаваемая через сеть без установления соединения. Каждая датаграмма независима: она может идти своим маршрутом, прийти в другом порядке или не прийти вовсе.

// UDP-сервер: приём датаграмм
DatagramSocket serverSocket = new DatagramSocket(9876);
byte[] buffer = new byte[1024];
DatagramPacket packet = new DatagramPacket(buffer, buffer.length);
serverSocket.receive(packet);  // Блокирующее ожидание датаграммы
String received = new String(packet.getData(), 0, packet.getLength());
// UDP-клиент: отправка датаграммы
DatagramSocket clientSocket = new DatagramSocket();  // эфемерный порт
byte[] sendData = "Hello, UDP".getBytes();
DatagramPacket sendPacket = new DatagramPacket(
    sendData, sendData.length, 
    InetAddress.getByName("localhost"), 9876
);
clientSocket.send(sendPacket);  // Отправка без установления соединения

Задержка (latency) — это время, которое требуется пакету для прохождения от отправителя к получателю. В TCP задержка включает время рукопожатия, ожидание ACK, повторные передачи. В UDP задержка минимальна: данные отправляются сразу.

WebRTC (Web Real-Time Communication) — это открытый фреймворк для организации передачи потоковых данных, голосовых вызовов и видеоконференций между браузерами и приложениями без установки плагинов. Он использует UDP для передачи медиа-потоков через протокол SRTP (Secure RTP).

public class NioServer {
    public static void main(String[] args) throws Exception {
        // ServerSocketChannel — неблокирующий серверный канал
        ServerSocketChannel serverChannel = ServerSocketChannel.open();
        serverChannel.bind(new InetSocketAddress(8080));
        serverChannel.configureBlocking(false);  // неблокирующий режим
        
        // Selector — мультиплексор, который мониторит множество каналов
        Selector selector = Selector.open();
        serverChannel.register(selector, SelectionKey.OP_ACCEPT);
        
        while (true) {
            // select() блокирует до появления событий на любом из зарегистрированных каналов
            selector.select();
            Set<SelectionKey> keys = selector.selectedKeys();
            Iterator<SelectionKey> it = keys.iterator();
            
            while (it.hasNext()) {
                SelectionKey key = it.next();
                it.remove();  // обязательно удаляем обработанный ключ
                
                if (key.isAcceptable()) {
                    // Новое входящее соединение
                    SocketChannel client = serverChannel.accept();
                    client.configureBlocking(false);
                    client.register(selector, SelectionKey.OP_READ);
                } else if (key.isReadable()) {
                    // Данные доступны для чтения
                    SocketChannel client = (SocketChannel) key.channel();
                    ByteBuffer buffer = ByteBuffer.allocate(1024);
                    int bytesRead = client.read(buffer);
                    if (bytesRead == -1) {
                        client.close();  // соединение закрыто клиентом
                    } else {
                        buffer.flip();  // переключаем буфер в режим чтения
                        // обработка данных...
                    }
                }
            }
        }
    }
}

Канал (Channel) в NIO — это абстракция для ввода-вывода, которая отличается от потоков (Stream) тем, что поддерживает неблокирующий режим и может работать в обе стороны (чтение и запись). SocketChannel — это канал для TCP-соединения, DatagramChannel — для UDP.

Селектор (Selector) — это механизм мультиплексирования ввода-вывода. Один поток может мониторить множество каналов, ожидая событий (готовность к чтению, записи, подключению). Это позволяет обслуживать тысячи соединений одним или несколькими потоками вместо одного потока на соединение.

SelectionKey — это токен, представляющий зарегистрированный канал в селекторе. Он хранит информацию о канале, селекторе и интересующих операциях (OP_ACCEPT, OP_CONNECT, OP_READ, OP_WRITE).

HeapByteBuffer — буфер, размещённый в куче JVM (Heap). При чтении из канала данные сначала копируются во временный буфер в нативной памяти (выделенный JNI), а затем — в массив byte[] в куче. Это двойное копирование снижает производительность.

DirectByteBuffer — буфер, размещённый в нативной памяти (native memory, вне кучи JVM). При чтении данные копируются напрямую из сокет-буфера ядра в нативную память, минуя кучу. Это устраняет одно копирование и позволяет использовать zero-copy техники на уровне ОС.

// HeapByteBuffer: данные в куче, медленнее при I/O
ByteBuffer heapBuffer = ByteBuffer.allocate(1024);

// DirectByteBuffer: данные в нативной памяти, быстрее при I/O
ByteBuffer directBuffer = ByteBuffer.allocateDirect(1024);

Zero-copy — это техника, при которой данные не копируются между буферами в пользовательском пространстве, а передаются по ссылке или напрямую из ядра в целевой буфер. В Java FileChannel.transferTo() и transferFrom() используют zero-copy для передачи данных между файлами и сокетами без промежуточного буфера в пользовательском пространстве.

Cleaner — это механизм в JVM, использующий PhantomReference (фантомную ссылку) для регистрации callback-функции, которая вызывается, когда объект становится пригодным для сборки мусора. Когда DirectByteBuffer собирается GC, Cleaner вызывает нативный метод free(), который освобождает блок нативной памяти через Unsafe.freeMemory().

PhantomReference — это тип ссылки в Java, который позволяет узнать, что объект был финализирован сборщиком мусора, но ещё не удалён. В отличие от WeakReference и SoftReference, phantom reference не даёт доступа к объекту, но гарантирует, что объект уже недостижим.

// Правильный паттерн: try-with-resources для автоматического закрытия
// Closeable — интерфейс, требующий реализации метода close()
try (SocketChannel channel = SocketChannel.open(new InetSocketAddress("host", 80))) {
    ByteBuffer buffer = ByteBuffer.allocateDirect(4096);
    channel.read(buffer);
}  // channel.close() вызывается автоматически, освобождая файловый дескриптор

import java.net.InetAddress;

public class Task140826 {
    public static void main(String[] args) throws Exception {
        InetAddress addr = InetAddress.getByName("");
        System.out.println(addr.getHostAddress());
    }
}