gadget59.ru лекции
Сокеты · Подробно · 24 слайда

Сокеты в Java: подробно о UDP, многопоточности, таймаутах, SSL и NIO

Сокеты в Java: подробно

В базовой лекции мы разобрали TCP-сокеты: клиент, сервер, передача строк и JSON. Но реальные приложения сложнее: они обслуживают много клиентов одновременно, работают с UDP, шифруют данные и корректно обрабатывают разрывы соединения.

📡 UDP 🧵 Многопоточность ⏱️ Таймауты 🔒 SSL ⚙️ Nagle ⚡ NIO
Эта лекция — продолжение базовой. Если вы не читали 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, «протокол пользовательских датаграмм») — это способ передачи данных по сети, при котором отправитель не проверяет, дошло ли сообщение до получателя.

UDP — это как отправить открытку по почте. Вы бросили её в ящик и пошли дальше. Дошла ли она — вы не знаете. Но зато быстро.
Что такое «датаграмма»?

Датаграмма — это маленький независимый пакет данных. В отличие от TCP, где данные идут потоком, в UDP каждое сообщение — отдельный пакет. Он либо дойдёт целиком, либо не дойдёт вовсе. Но не «наполовину».

UDP используется там, где важнее скорость, чем гарантия доставки: видеозвонки, онлайн-игры, DNS-запросы, стриминг.

DatagramSocket — что это?

DatagramSocket — это класс в Java, который представляет UDP-сокет. Через него можно отправлять и принимать датаграммы (пакеты).

Зачем нужен DatagramSocket?

Он нужен, чтобы программа могла «слушать» порт и принимать UDP-пакеты, а также отправлять их другим программам. Это аналог Socket для TCP, но с другим поведением.

DatagramSocket — это как почтовый ящик. Вы можете в него бросать письма (отправлять) и забирать из него (принимать).

Как создать DatagramSocket

// Создаём UDP-сокет на порту 9000 DatagramSocket socket = new DatagramSocket(9000);

Разберём строку по частям:

  • DatagramSocket — имя класса.
  • socket — имя переменной, придумываем сами.
  • new — оператор создания объекта.
  • 9000 — номер порта. Это число от 0 до 65535. Порты до 1024 заняты системными службами, поэтому используем 9000.
Если порт уже занят другой программой, будет выброшено исключение BindException. В таком случае выберите другой номер порта.

DatagramPacket — что это?

DatagramPacket — это класс, который представляет один UDP-пакет. В нём лежат три вещи:

📦
Данные
сами байты, которые передаются
📍
Адрес
IP-адрес получателя (или отправителя)
🔢
Порт
номер порта получателя
Зачем нужен DatagramPacket?

Сам сокет не знает, что и кому отправлять. DatagramPacket — это «конверт», в который мы кладём данные, пишем адрес и порт. Сокет только «относит» этот конверт.

DatagramPacket — это конверт с письмом. На конверте написан адрес получателя. DatagramSocket — это почтальон, который доставляет конверт.

Как отправить UDP-пакет

Пошагово: что нужно сделать, чтобы отправить сообщение через UDP.

Шаг 1. Создать сокет

// Без указания порта — порт выберется автоматически DatagramSocket socket = new DatagramSocket();

Когда мы только отправляем (клиент), порт указывать не нужно. Java сама выберет свободный.

Шаг 2. Узнать адрес сервера

// InetAddress — это IP-адрес InetAddress address = InetAddress.getByName("localhost");

InetAddress.getByName("localhost") — получает IP-адрес по имени. localhost — это «этот же компьютер». Если сервер на другом компьютере, указываем его IP (например, "192.168.1.10").

Шаг 3. Подготовить данные

// Строку превращаем в массив байтов byte[] data = "Привет!".getBytes();

Сеть передаёт только байты. Поэтому строку нужно превратить в массив байтов через getBytes().

Шаг 4. Создать пакет

// DatagramPacket(данные, длина, адрес, порт) DatagramPacket packet = new DatagramPacket( data, // сами байты data.length, // сколько байтов отправлять address, // куда (IP-адрес) 9000 // на какой порт );

Шаг 5. Отправить

socket.send(packet);
Пакет отправлен. Если сервер не запущен — он просто потеряется. UDP не проверяет доставку.

Как принять UDP-пакет

Теперь — что делает сервер, чтобы принять пакет.

Шаг 1. Создать сокет на порту

// Слушаем порт 9000 DatagramSocket socket = new DatagramSocket(9000);

Сервер обязательно указывает порт — иначе клиенты не знают, куда отправлять.

Шаг 2. Создать буфер и пакет

// Буфер для приёма — 1024 байта byte[] buffer = new byte[1024]; // Пакет, в который будет записан принятый пакет DatagramPacket packet = new DatagramPacket(buffer, buffer.length);

Буфер — это «место», куда будет записан пришедший пакет. 1024 байта обычно хватает для небольших сообщений. Если сообщение больше — часть потеряется.

Шаг 3. Принять

// Ждём, пока не придёт пакет socket.receive(packet);

receive — блокирующий метод. Он ждёт, пока не придёт пакет. Пока не придёт — программа «висит» на этой строке.

Шаг 4. Прочитать данные

// Превращаем байты обратно в строку String message = new String( packet.getData(), // все байты из буфера 0, // начиная с 0 packet.getLength() // сколько реально пришло );

getLength() — важно! Мы не знаем, сколько байтов пришло. Буфер 1024, но пришло, например, 10 байт. getLength() покажет 10. Если использовать buffer.length — получим 1024 байта, из которых 1014 — мусор.

Не используйте buffer.length для чтения строки. Только packet.getLength(). Это классическая ошибка.

Полный код UDP-клиента

Соберём всё вместе. Каждая строка прокомментирована.

import java.net.*; // DatagramSocket, DatagramPacket, InetAddress public class UdpClient { public static void main(String[] args) throws Exception { // 1. Создаём UDP-сокет. Порт не указываем — Java выберет сама DatagramSocket socket = new DatagramSocket(); // 2. Получаем IP-адрес сервера по имени "localhost" InetAddress address = InetAddress.getByName("localhost"); // 3. Готовим сообщение и превращаем его в массив байтов String message = "Привет, сервер!"; byte[] data = message.getBytes(); // 4. Создаём пакет: данные + длина + адрес + порт DatagramPacket packet = new DatagramPacket( data, // что отправляем data.length, // сколько байтов address, // куда (IP) 9000 // на какой порт ); // 5. Отправляем пакет socket.send(packet); // 6. Закрываем сокет — освобождаем ресурсы socket.close(); // 7. Сообщаем пользователю System.out.println("Пакет отправлен"); } }
Разбор по шагам
  1. new DatagramSocket() — создаёт «почтовый ящик» для отправки.
  2. InetAddress.getByName("localhost") — находит адрес. localhost = 127.0.0.1 = этот же компьютер.
  3. message.getBytes() — превращает строку в байты. Сеть понимает только байты.
  4. new DatagramPacket(...) — создаёт конверт с адресом и данными.
  5. socket.send(packet) — отправляет пакет в сеть.
  6. socket.close() — закрывает сокет. Всегда закрывайте!

Полный код UDP-сервера

Теперь сервер. Он слушает порт 9000 и принимает пакеты.

import java.net.*; public class UdpServer { public static void main(String[] args) throws Exception { // 1. Создаём UDP-сокет и слушаем порт 9000 DatagramSocket socket = new DatagramSocket(9000); System.out.println("Сервер слушает порт 9000"); // 2. Готовим буфер для приёма byte[] buffer = new byte[1024]; // 3. Бесконечный цикл — сервер работает всегда while (true) { // 4. Создаём пакет, в который запишется принятое DatagramPacket packet = new DatagramPacket(buffer, buffer.length); // 5. Ждём пакет (блокирующая операция) socket.receive(packet); // 6. Превращаем байты в строку String message = new String( packet.getData(), // буфер с данными 0, // с начала packet.getLength() // сколько байтов пришло ); // 7. Выводим в консоль System.out.println("Получено: " + message); } } }
socket.receive() блокирует программу. Пока пакет не придёт — код ниже не выполнится. Это нормально для сервера: он «ждёт клиентов».

TCP vs UDP: когда что

Теперь, когда мы знаем оба протокола, сравним их.

КритерийTCPUDP Соединениеустанавливаетсянет Гарантия доставкиданет Порядок пакетовсохраняетсяне гарантируется Скоростьмедленнеебыстрее Использованиевеб, почта, файлыигры, видео, DNS
TCP — когда важна целостность данных. Если потеряется пакет — TCP его переспросит.
UDP — когда важна скорость. Если потеряется пакет — ничего страшного, следующий придёт.
TCP — это заказное письмо с уведомлением. UDP — это обычная открытка. Оба способа работают, но для разных задач.

Проблема: один клиент за раз

В базовом примере TCP-сервер обрабатывает одного клиента. Давайте посмотрим, почему это плохо.

// Такой сервер обслуживает только одного клиента Socket client = serverSocket.accept(); // ждём клиента handleClient(client); // обслуживаем его // пока handleClient не закончит — другие клиенты ждут
Что происходит шаг за шагом
  1. Сервер вызывает accept() — ждёт клиента.
  2. Приходит клиент №1. accept() возвращает его сокет.
  3. Сервер вызывает handleClient() — обслуживает клиента №1.
  4. Пока handleClient() не закончит — сервер не вернётся к accept().
  5. Клиент №2 в это время не может подключиться — его никто не «слушает».
Если клиент №1 «зависнет» (например, не отправит данные), остальные не смогут подключиться. Это неприемлемо для реального сервера.
Решение — многопоточность: каждый клиент обслуживается в отдельном потоке.

Thread — что это?

Thread (по-английски «нить») — это поток выполнения. Программа может выполнять несколько потоков одновременно.

Что такое поток?

Представьте, что программа — это повар на кухне. Один поток — один повар. Если повар один, он делает всё по очереди: сначала режет овощи, потом варит суп, потом жарит мясо. Если поваров несколько — они работают параллельно: один режет, другой варит, третий жарит.

Каждый поток в Java — это «отдельный повар». Он выполняет свой код независимо от других.

Thread — это как отдельный работник. Если у вас много клиентов — наймите на каждого отдельного работника (поток), и они будут обслуживать клиентов параллельно.

Как создать поток

// Создаём поток, который выполнит код внутри лямбды Thread thread = new Thread(() -> { // код, который выполнится в новом потоке System.out.println("Я в отдельном потоке!"); }); // Запускаем поток thread.start();
  • new Thread(...) — создаёт поток. В скобках — что поток должен сделать.
  • () -> { ... } — лямбда-выражение. Это код, который выполнится в потоке.
  • thread.start() — запускает поток. Важно: именно start(), а не run().
Если вызвать run() вместо start(), код выполнится в текущем потоке, а не в новом. Это классическая ошибка.

Многопоточный сервер с Thread

Теперь применим Thread к нашему серверу.

try (ServerSocket serverSocket = new ServerSocket(8080)) { // Бесконечный цикл — сервер работает всегда while (true) { // 1. Ждём нового клиента Socket client = serverSocket.accept(); // 2. Создаём отдельный поток для этого клиента Thread thread = new Thread(() -> { handleClient(client); // обслуживаем клиента }); // 3. Запускаем поток thread.start(); // 4. Сразу возвращаемся к accept() и ждём следующего } }
Что происходит шаг за шагом
  1. Сервер вызывает accept() — ждёт клиента.
  2. Приходит клиент №1. accept() возвращает его сокет.
  3. Создаётся новый поток, который будет обслуживать клиента №1.
  4. Поток запускается через start().
  5. Сервер сразу возвращается к accept() — ждёт клиента №2.
  6. Клиент №2 подключается. Создаётся ещё один поток.
  7. И так далее — каждый клиент в своём потоке.
Теперь сервер обслуживает много клиентов одновременно. Один «зависший» клиент не блокирует остальных.
Создавать новый поток на каждого клиента — плохо при большом количестве клиентов. Потоки «дорогие» по памяти. Для тысяч клиентов лучше использовать пул потоков (следующий слайд).

ExecutorService — что это?

ExecutorService — это пул потоков. Набор заранее созданных потоков, которые переиспользуются для разных задач.

Что такое пул потоков?

Представьте, что у вас 10 работников. Приходит 100 клиентов. Вы не нанимаете 100 новых работников — вы ставите клиентов в очередь. 10 работников обслуживают их по очереди. Когда работник освобождается — берёт следующего из очереди.

Пул потоков работает так же: есть 10 потоков, задачи (клиенты) ждут в очереди, потоки берут их по одному.

ExecutorService — это как бригада из 10 рабочих. Клиенты стоят в очереди. Рабочие обслуживают их по одному, но 10 штук одновременно.

Как создать пул

// Создаём пул из 10 потоков ExecutorService pool = Executors.newFixedThreadPool(10);
  • Executors — класс-помощник с фабричными методами.
  • newFixedThreadPool(10) — создаёт пул ровно из 10 потоков.
  • Эти 10 потоков будут переиспользоваться для всех задач.

Многопоточный сервер с ExecutorService

Заменим new Thread на пул потоков.

import java.util.concurrent.ExecutorService; import java.util.concurrent.Executors; // 1. Создаём пул из 10 потоков (один раз при старте) ExecutorService pool = Executors.newFixedThreadPool(10); try (ServerSocket serverSocket = new ServerSocket(8080)) { while (true) { // 2. Ждём клиента Socket client = serverSocket.accept(); // 3. Отправляем задачу в пул (не создаём новый поток!) pool.submit(() -> handleClient(client)); } }
Что происходит шаг за шагом
  1. При старте сервера создаётся пул из 10 потоков.
  2. Сервер вызывает accept() — ждёт клиента.
  3. Приходит клиент. accept() возвращает его сокет.
  4. Задача (обслуживание клиента) отправляется в пул через submit().
  5. Если есть свободный поток — он берёт задачу и выполняет.
  6. Если все 10 потоков заняты — задача ждёт в очереди.
  7. Когда поток освобождается — он берёт следующую задачу из очереди.
Пул потоков эффективнее: не создаёт новые потоки на каждого клиента. Потоки переиспользуются.
newFixedThreadPool(10) — 10 потоков хватит для учебного проекта. В реальных системах количество потоков подбирают под нагрузку.

Таймауты — что это?

Таймаут (от английского timeout — «истекло время») — это ограничение времени на какую-то операцию. Если операция не завершилась за указанное время — выбрасывается исключение.

Зачем нужны таймауты?

Без таймаута программа может «зависнуть» навсегда. Например, клиент подключился к серверу, но не отправляет данные. Сервер вызывает readLine() и ждёт. Если клиент никогда не отправит данные — сервер будет ждать вечно.

Таймаут решает эту проблему: «Жди не дольше 5 секунд. Если за 5 секунд ничего не пришло — прерывайся с ошибкой».

Таймаут — это как будильник. «Если я не проснусь за 10 минут — звони». Без будильника можно проспать весь день.

Виды таймаутов

ТаймаутМетодЧто ограничивает Подключенияconnect(addr, timeout)время на подключение к серверу ЧтенияsetSoTimeout(ms)время на ожидание данных

Таймауты в коде

Покажем, как установить таймауты.

Таймаут подключения

// Создаём сокет БЕЗ подключения Socket socket = new Socket(); // Подключаемся с таймаутом 5000 мс (5 секунд) socket.connect( new InetSocketAddress("localhost", 8080), 5000 // 5000 миллисекунд = 5 секунд );
Что происходит
  1. new Socket() — создаёт сокет, но не подключает.
  2. connect(addr, 5000) — пытается подключиться.
  3. Если за 5 секунд подключение не удалось — выбрасывается SocketTimeoutException.
  4. Программа не «висит» бесконечно.

Таймаут чтения

// После подключения устанавливаем таймаут на чтение socket.setSoTimeout(3000); // 3 секунды // Теперь readLine() будет ждать данные не дольше 3 секунд BufferedReader in = new BufferedReader( new InputStreamReader(socket.getInputStream()) ); String line = in.readLine(); // если 3 секунды нет данных — исключение
Без setSoTimeout метод readLine() будет ждать данные бесконечно. Если клиент «завис» — сервер тоже зависнет. Всегда ставьте таймаут.

SSLSocket — что это?

SSLSocket — это обычный сокет, но с шифрованием. Все данные, которые передаются через него, автоматически шифруются перед отправкой и расшифровываются при получении.

Что такое SSL и TLS?

SSL (Secure Sockets Layer, «уровень защищённых сокетов») — старый протокол шифрования. TLS (Transport Layer Security, «безопасность транспортного уровня») — его современная версия.

Когда вы заходите на сайт по HTTPS — используется TLS. Данные шифруются, и никто не может их прочитать по пути.

SSLSocket — это как заказное письмо в запечатанном конверте. Даже если кто-то перехватит — не прочитает.
Обычный Socket передаёт данные открытым текстом. Пароли, номера карт, личные сообщения — всё видно любому, кто «слушает» сеть. Для реальных приложений — только SSL.

SSLSocket в коде

Создание SSLSocket немного отличается от обычного Socket.

import javax.net.ssl.SSLSocket; import javax.net.ssl.SSLSocketFactory; // 1. Получаем фабрику SSL-сокетов SSLSocketFactory factory = (SSLSocketFactory) SSLSocketFactory.getDefault(); // 2. Создаём SSL-сокет к серверу на порт 443 SSLSocket socket = (SSLSocket) factory.createSocket("example.com", 443); // 3. Дальше работаем как с обычным сокетом // in/out потоки, чтение/запись — всё то же самое
Что происходит шаг за шагом
  1. SSLSocketFactory.getDefault() — получает стандартную фабрику SSL.
  2. factory.createSocket("example.com", 443) — создаёт SSL-сокет к серверу.
  3. Порт 443 — стандартный порт для HTTPS.
  4. Дальше — те же getInputStream() и getOutputStream(), что и у обычного Socket.
SSLSocket — часть стандартной библиотеки Java (javax.net.ssl). Ничего дополнительно скачивать не нужно.
Для работы с SSL нужны сертификаты. Если сертификат сервера не доверенный — Java выбросит исключение SSLHandshakeException. Это защита от поддельных серверов.

Nagle-алгоритм

Nagle-алгоритм — это механизм в TCP, который объединяет мелкие пакеты в один, чтобы уменьшить нагрузку на сеть.

Как работает Nagle

Представьте, что вы отправляете 10 маленьких сообщений по 1 байту. Если отправлять их отдельно — будет 10 пакетов. Nagle ждёт, пока накопится буфер, и отправляет всё одним пакетом.

Плюс: меньше пакетов, эффективнее сеть. Минус: задержка — маленькое сообщение ждёт, пока накопится буфер.

✅
Плюс
Меньше пакетов, эффективнее сеть.
❌
Минус
Задержка: маленькие сообщения ждут.

Как отключить Nagle

// Отключаем Nagle-алгоритм socket.setTcpNoDelay(true);
Для игр и интерактивных приложений, где важна мгновенная реакция, Nagle отключают. Для передачи файлов — оставляют.

NIO — что это?

NIO (New Input/Output, «новый ввод-вывод») — это альтернативный способ работы с сетью, который позволяет одному потоку обслуживать много соединений.

Чем NIO отличается от обычных сокетов

Обычные сокеты — блокирующие. accept() и read() ждут, пока данные придут. Один поток — одно соединение.

NIO — неблокирующий. Поток может проверить: «Есть ли данные?». Если нет — идти дальше. Один поток может обслуживать сотни соединений.

Обычный сокет — это как официант, который стоит у одного столика и ждёт заказ. NIO — как официант, который обходит все столики и спрашивает: «Кто готов?».

Основные классы NIO

КлассЧто делает ServerSocketChannelнеблокирующий сервер SocketChannelнеблокирующий клиент Selectorмультиплексор событий ByteBufferбуфер для данных

NIO: пример

Простой пример NIO-сервера.

import java.nio.channels.ServerSocketChannel; import java.net.InetSocketAddress; // 1. Открываем канал ServerSocketChannel server = ServerSocketChannel.open(); // 2. Привязываем к порту 8080 server.bind(new InetSocketAddress(8080)); // 3. Делаем неблокирующим server.configureBlocking(false); // 4. Дальше — цикл с Selector (сложнее, чем обычный accept)
NIO сложнее в освоении. Для базовых проектов хватает многопоточного сервера. NIO нужен для высоконагруженных систем (например, веб-серверов).
Мы не будем разбирать NIO глубоко. Это тема для отдельной лекции. Сейчас достаточно знать, что такое бывает.

Типичные ошибки

Разберём ошибки, которые чаще всего встречаются.

1. Забыли про таймаут
Сервер «виснет» на одном клиенте. Решение: setSoTimeout.
2. Забыли закрыть сокет
Ресурс остаётся занятым. Решение: try-with-resources.
3. Не обработали разрыв соединения
Сервер падает с SocketException. Решение: try-catch.
4. Блокирующий accept на клиенте
Клиент ждёт данных, которых не будет. Решение: таймаут или закрытие по условию.
5. Nagle-задержки
Клиент не получает данные вовремя. Решение: setTcpNoDelay(true).
6. Шифрование не включено
Пароли уходят открытым текстом. Решение: SSLSocket.
7. Использование buffer.length вместо packet.getLength()
В строке появляется мусор. Решение: всегда packet.getLength().

Итоги лекции

Подведём итоги. Вот что вы теперь знаете.

  • ✅ UDP — быстрый протокол без гарантии доставки.
  • ✅ DatagramSocket — UDP-сокет для отправки и приёма.
  • ✅ DatagramPacket — «конверт» с данными и адресом.
  • ✅ Thread — поток выполнения. Позволяет обслуживать много клиентов.
  • ✅ ExecutorService — пул потоков. Эффективнее, чем создавать новый поток на каждого.
  • ✅ Таймауты — защита от «вечного ожидания».
  • ✅ SSLSocket — шифрование данных.
  • ✅ Nagle-алгоритм — и зачем его отключать.
  • ✅ NIO — неблокирующий ввод-вывод (обзорно).
  • ✅ Типичные ошибки — и как их избежать.
Теперь вы знаете не только «как подключиться», но и «как сделать это надёжно и безопасно».