Сокеты в Java: подробно
В базовой лекции мы разобрали TCP-сокеты: клиент, сервер, передача строк и JSON. Но реальные приложения сложнее: они обслуживают много клиентов одновременно, работают с UDP, шифруют данные и корректно обрабатывают разрывы соединения.
oaip43.html, вернитесь к ней. Здесь мы разберём: UDP-сокеты, многопоточный сервер, таймауты, SSL, Nagle-алгоритм, неблокирующий ввод-вывод и типичные ошибки реальных приложений.
План лекции
Сегодня мы пойдём от «базового TCP» к «продвинутому сетевому программированию».
- 1 UDP-сокеты: что это и зачем
- 2 DatagramSocket — UDP-сокет
- 3 DatagramPacket — пакет данных
- 4 Как отправить и принять UDP-пакет
- 5 TCP vs UDP: когда что
- 6 Проблема «один клиент за раз»
- 7 Thread — поток для каждого клиента
- 8 ExecutorService — пул потоков
- 9 Таймауты: зачем и как
- 10 SSLSocket — шифрование
- 11 Nagle-алгоритм
- 12 NIO — обзорно
UDP — что это?
UDP (User Datagram Protocol, «протокол пользовательских датаграмм») — это способ передачи данных по сети, при котором отправитель не проверяет, дошло ли сообщение до получателя.
Датаграмма — это маленький независимый пакет данных. В отличие от TCP, где данные идут потоком, в UDP каждое сообщение — отдельный пакет. Он либо дойдёт целиком, либо не дойдёт вовсе. Но не «наполовину».
DatagramSocket — что это?
DatagramSocket — это класс в Java, который представляет UDP-сокет. Через него можно отправлять и принимать датаграммы (пакеты).
Он нужен, чтобы программа могла «слушать» порт и принимать UDP-пакеты, а также отправлять их другим программам. Это аналог Socket для TCP, но с другим поведением.
Как создать DatagramSocket
Разберём строку по частям:
DatagramSocket— имя класса.socket— имя переменной, придумываем сами.new— оператор создания объекта.9000— номер порта. Это число от 0 до 65535. Порты до 1024 заняты системными службами, поэтому используем 9000.
BindException. В таком случае выберите другой номер порта.DatagramPacket — что это?
DatagramPacket — это класс, который представляет один UDP-пакет. В нём лежат три вещи:
сами байты, которые передаются
IP-адрес получателя (или отправителя)
номер порта получателя
Сам сокет не знает, что и кому отправлять. DatagramPacket — это «конверт», в который мы кладём данные, пишем адрес и порт. Сокет только «относит» этот конверт.
Как отправить UDP-пакет
Пошагово: что нужно сделать, чтобы отправить сообщение через UDP.
Шаг 1. Создать сокет
Когда мы только отправляем (клиент), порт указывать не нужно. Java сама выберет свободный.
Шаг 2. Узнать адрес сервера
InetAddress.getByName("localhost") — получает IP-адрес по имени. localhost — это «этот же компьютер». Если сервер на другом компьютере, указываем его IP (например, "192.168.1.10").
Шаг 3. Подготовить данные
Сеть передаёт только байты. Поэтому строку нужно превратить в массив байтов через getBytes().
Шаг 4. Создать пакет
Шаг 5. Отправить
Как принять UDP-пакет
Теперь — что делает сервер, чтобы принять пакет.
Шаг 1. Создать сокет на порту
Сервер обязательно указывает порт — иначе клиенты не знают, куда отправлять.
Шаг 2. Создать буфер и пакет
Буфер — это «место», куда будет записан пришедший пакет. 1024 байта обычно хватает для небольших сообщений. Если сообщение больше — часть потеряется.
Шаг 3. Принять
receive — блокирующий метод. Он ждёт, пока не придёт пакет. Пока не придёт — программа «висит» на этой строке.
Шаг 4. Прочитать данные
getLength() — важно! Мы не знаем, сколько байтов пришло. Буфер 1024, но пришло, например, 10 байт. getLength() покажет 10. Если использовать buffer.length — получим 1024 байта, из которых 1014 — мусор.
buffer.length для чтения строки. Только packet.getLength(). Это классическая ошибка.Полный код UDP-клиента
Соберём всё вместе. Каждая строка прокомментирована.
- new DatagramSocket() — создаёт «почтовый ящик» для отправки.
- InetAddress.getByName("localhost") — находит адрес.
localhost= 127.0.0.1 = этот же компьютер. - message.getBytes() — превращает строку в байты. Сеть понимает только байты.
- new DatagramPacket(...) — создаёт конверт с адресом и данными.
- socket.send(packet) — отправляет пакет в сеть.
- socket.close() — закрывает сокет. Всегда закрывайте!
Полный код UDP-сервера
Теперь сервер. Он слушает порт 9000 и принимает пакеты.
socket.receive() блокирует программу. Пока пакет не придёт — код ниже не выполнится. Это нормально для сервера: он «ждёт клиентов».TCP vs UDP: когда что
Теперь, когда мы знаем оба протокола, сравним их.
UDP — когда важна скорость. Если потеряется пакет — ничего страшного, следующий придёт.
Проблема: один клиент за раз
В базовом примере TCP-сервер обрабатывает одного клиента. Давайте посмотрим, почему это плохо.
- Сервер вызывает
accept()— ждёт клиента. - Приходит клиент №1.
accept()возвращает его сокет. - Сервер вызывает
handleClient()— обслуживает клиента №1. - Пока
handleClient()не закончит — сервер не вернётся кaccept(). - Клиент №2 в это время не может подключиться — его никто не «слушает».
Thread — что это?
Thread (по-английски «нить») — это поток выполнения. Программа может выполнять несколько потоков одновременно.
Представьте, что программа — это повар на кухне. Один поток — один повар. Если повар один, он делает всё по очереди: сначала режет овощи, потом варит суп, потом жарит мясо. Если поваров несколько — они работают параллельно: один режет, другой варит, третий жарит.
Каждый поток в Java — это «отдельный повар». Он выполняет свой код независимо от других.
Как создать поток
new Thread(...)— создаёт поток. В скобках — что поток должен сделать.() -> { ... }— лямбда-выражение. Это код, который выполнится в потоке.thread.start()— запускает поток. Важно: именноstart(), а неrun().
run() вместо start(), код выполнится в текущем потоке, а не в новом. Это классическая ошибка.Многопоточный сервер с Thread
Теперь применим Thread к нашему серверу.
- Сервер вызывает
accept()— ждёт клиента. - Приходит клиент №1.
accept()возвращает его сокет. - Создаётся новый поток, который будет обслуживать клиента №1.
- Поток запускается через
start(). - Сервер сразу возвращается к
accept()— ждёт клиента №2. - Клиент №2 подключается. Создаётся ещё один поток.
- И так далее — каждый клиент в своём потоке.
ExecutorService — что это?
ExecutorService — это пул потоков. Набор заранее созданных потоков, которые переиспользуются для разных задач.
Представьте, что у вас 10 работников. Приходит 100 клиентов. Вы не нанимаете 100 новых работников — вы ставите клиентов в очередь. 10 работников обслуживают их по очереди. Когда работник освобождается — берёт следующего из очереди.
Пул потоков работает так же: есть 10 потоков, задачи (клиенты) ждут в очереди, потоки берут их по одному.
Как создать пул
Executors— класс-помощник с фабричными методами.newFixedThreadPool(10)— создаёт пул ровно из 10 потоков.- Эти 10 потоков будут переиспользоваться для всех задач.
Многопоточный сервер с ExecutorService
Заменим new Thread на пул потоков.
- При старте сервера создаётся пул из 10 потоков.
- Сервер вызывает
accept()— ждёт клиента. - Приходит клиент.
accept()возвращает его сокет. - Задача (обслуживание клиента) отправляется в пул через
submit(). - Если есть свободный поток — он берёт задачу и выполняет.
- Если все 10 потоков заняты — задача ждёт в очереди.
- Когда поток освобождается — он берёт следующую задачу из очереди.
Таймауты — что это?
Таймаут (от английского timeout — «истекло время») — это ограничение времени на какую-то операцию. Если операция не завершилась за указанное время — выбрасывается исключение.
Без таймаута программа может «зависнуть» навсегда. Например, клиент подключился к серверу, но не отправляет данные. Сервер вызывает readLine() и ждёт. Если клиент никогда не отправит данные — сервер будет ждать вечно.
Таймаут решает эту проблему: «Жди не дольше 5 секунд. Если за 5 секунд ничего не пришло — прерывайся с ошибкой».
Виды таймаутов
Таймауты в коде
Покажем, как установить таймауты.
Таймаут подключения
new Socket()— создаёт сокет, но не подключает.connect(addr, 5000)— пытается подключиться.- Если за 5 секунд подключение не удалось — выбрасывается
SocketTimeoutException. - Программа не «висит» бесконечно.
Таймаут чтения
setSoTimeout метод readLine() будет ждать данные бесконечно. Если клиент «завис» — сервер тоже зависнет. Всегда ставьте таймаут.SSLSocket — что это?
SSLSocket — это обычный сокет, но с шифрованием. Все данные, которые передаются через него, автоматически шифруются перед отправкой и расшифровываются при получении.
SSL (Secure Sockets Layer, «уровень защищённых сокетов») — старый протокол шифрования. TLS (Transport Layer Security, «безопасность транспортного уровня») — его современная версия.
Когда вы заходите на сайт по HTTPS — используется TLS. Данные шифруются, и никто не может их прочитать по пути.
Socket передаёт данные открытым текстом. Пароли, номера карт, личные сообщения — всё видно любому, кто «слушает» сеть. Для реальных приложений — только SSL.SSLSocket в коде
Создание SSLSocket немного отличается от обычного Socket.
SSLSocketFactory.getDefault()— получает стандартную фабрику SSL.factory.createSocket("example.com", 443)— создаёт SSL-сокет к серверу.- Порт 443 — стандартный порт для HTTPS.
- Дальше — те же
getInputStream()иgetOutputStream(), что и у обычного Socket.
SSLSocket — часть стандартной библиотеки Java (javax.net.ssl). Ничего дополнительно скачивать не нужно.SSLHandshakeException. Это защита от поддельных серверов.Nagle-алгоритм
Nagle-алгоритм — это механизм в TCP, который объединяет мелкие пакеты в один, чтобы уменьшить нагрузку на сеть.
Представьте, что вы отправляете 10 маленьких сообщений по 1 байту. Если отправлять их отдельно — будет 10 пакетов. Nagle ждёт, пока накопится буфер, и отправляет всё одним пакетом.
Плюс: меньше пакетов, эффективнее сеть. Минус: задержка — маленькое сообщение ждёт, пока накопится буфер.
Меньше пакетов, эффективнее сеть.
Задержка: маленькие сообщения ждут.
Как отключить Nagle
NIO — что это?
NIO (New Input/Output, «новый ввод-вывод») — это альтернативный способ работы с сетью, который позволяет одному потоку обслуживать много соединений.
Обычные сокеты — блокирующие. accept() и read() ждут, пока данные придут. Один поток — одно соединение.
NIO — неблокирующий. Поток может проверить: «Есть ли данные?». Если нет — идти дальше. Один поток может обслуживать сотни соединений.
Основные классы NIO
NIO: пример
Простой пример NIO-сервера.
Типичные ошибки
Разберём ошибки, которые чаще всего встречаются.
Сервер «виснет» на одном клиенте. Решение:
setSoTimeout.Ресурс остаётся занятым. Решение:
try-with-resources.Сервер падает с
SocketException. Решение: try-catch.Клиент ждёт данных, которых не будет. Решение: таймаут или закрытие по условию.
Клиент не получает данные вовремя. Решение:
setTcpNoDelay(true).Пароли уходят открытым текстом. Решение:
SSLSocket.buffer.length вместо packet.getLength()В строке появляется мусор. Решение: всегда
packet.getLength().Итоги лекции
Подведём итоги. Вот что вы теперь знаете.
- ✅ UDP — быстрый протокол без гарантии доставки.
- ✅ DatagramSocket — UDP-сокет для отправки и приёма.
- ✅ DatagramPacket — «конверт» с данными и адресом.
- ✅ Thread — поток выполнения. Позволяет обслуживать много клиентов.
- ✅ ExecutorService — пул потоков. Эффективнее, чем создавать новый поток на каждого.
- ✅ Таймауты — защита от «вечного ожидания».
- ✅ SSLSocket — шифрование данных.
- ✅ Nagle-алгоритм — и зачем его отключать.
- ✅ NIO — неблокирующий ввод-вывод (обзорно).
- ✅ Типичные ошибки — и как их избежать.