gadget59.ru практика
Сокеты · Практика · 26 слайдов

Практическая работа: многопоточный UDP + TCP сервер с логированием

Практика: многопоточный UDP + TCP сервер с логированием

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

📡 UDP-эхо 🔗 TCP-сервер 🧵 Пул потоков 📝 Логирование ⏱️ Таймауты
Мы создадим три класса: Logger (логирование в файл), MultiServer (TCP + UDP) и Main (точка входа). Каждая строка кода будет объяснена.
Формат: практическая работа, 2 академических часа. Понадобится JDK. Никаких сторонних библиотек — только стандартная Java.

Цель и задачи

Цель: получить практические навыки многопоточного сетевого программирования.

Что мы сделаем

  • 1 Напишем класс Logger — запись событий в файл.
  • 2 Напишем MultiServer — TCP + UDP одновременно.
  • 3 Используем пул потоков для TCP-клиентов.
  • 4 Добавим UDP-эхо: клиент отправляет пакет — сервер возвращает его.
  • 5 Добавим логирование каждого запроса.
  • 6 Обработаем разрыв соединения.
В результате получится сервер, который умеет работать с TCP и UDP одновременно и ведёт лог всех событий.

Схема приложения

Вот как устроено наше приложение.

Main
↓
TCP-сервер
порт 8080
UDP-сервер
порт 9000
↓ ↓
Logger (файл server.log)
КомпонентПортЧто делает TCP-сервер8080принимает клиентов, эхо-ответ UDP-сервер9000принимает пакеты, эхо-ответ Logger—пишет в server.log
Оба сервера работают в отдельных потоках, чтобы не блокировать друг друга. Main просто запускает их и ждёт.

Шаг 1: класс Logger

Logger — это класс для записи событий в файл. Он нужен, чтобы потом можно было посмотреть, что происходило на сервере.

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

Когда сервер работает, мы не видим, что происходит. Логи — это «дневник» сервера. Если что-то сломалось, мы открываем лог и смотрим, что было.

Logger — это как бортжурнал самолёта. Всё, что происходит, записывается. Потом можно прочитать и понять.
import java.io.FileWriter; import java.io.IOException; import java.io.PrintWriter; import java.time.LocalDateTime; import java.time.format.DateTimeFormatter; public class Logger { // Имя файла для логов private static final String LOG_FILE = "server.log"; // Формат даты и времени: 2026-11-15 14:30:00 private static final DateTimeFormatter FORMATTER = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss"); // Метод для записи сообщения в лог public static synchronized void log(String message) { // Получаем текущее время String time = LocalDateTime.now().format(FORMATTER); // Открываем файл в режиме добавления (true) try (PrintWriter writer = new PrintWriter( new FileWriter(LOG_FILE, true))) { // Записываем строку: [время] сообщение writer.println("[" + time + "] " + message); } catch (IOException e) { // Если не удалось записать — выводим в консоль System.err.println("Не удалось записать лог: " + e.getMessage()); } } }
Разбор по шагам
  1. LOG_FILE = "server.log" — имя файла, куда пишем.
  2. DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss") — формат даты. yyyy — год, MM — месяц, dd — день, HH — часы, mm — минуты, ss — секунды.
  3. synchronized — модификатор. Он гарантирует, что два потока не будут писать в файл одновременно.
  4. new FileWriter(LOG_FILE, true) — открывает файл. true означает «добавлять в конец», а не перезаписывать.
  5. writer.println(...) — записывает строку в файл.
  6. try (...) — try-with-resources. Закрывает файл автоматически.
synchronized — очень важный модификатор. Без него два потока могут одновременно открыть файл, и данные перемешаются или потеряются.

Шаг 2: TCP-сервер — начало

Теперь создадим TCP-сервер. Он будет принимать клиентов и отправлять им эхо-ответ.

Что такое «эхо-сервер»?

Эхо-сервер — это сервер, который возвращает то, что получил. Клиент отправляет «Привет» — сервер возвращает «Привет». Просто, но полезно для проверки соединения.

import java.io.*; import java.net.*; import java.util.concurrent.ExecutorService; import java.util.concurrent.Executors; public class MultiServer { // Порты для TCP и UDP private static final int TCP_PORT = 8080; private static final int UDP_PORT = 9000; // Пул из 10 потоков для TCP-клиентов private static final ExecutorService POOL = Executors.newFixedThreadPool(10); // Запуск TCP-сервера public static void startTcpServer() { try (ServerSocket serverSocket = new ServerSocket(TCP_PORT)) { Logger.log("TCP-сервер запущен на порту " + TCP_PORT); while (true) { // Ждём клиента Socket client = serverSocket.accept(); // Отправляем клиента в пул потоков POOL.submit(() -> handleTcpClient(client)); } } catch (IOException e) { Logger.log("Ошибка TCP-сервера: " + e.getMessage()); } } }
Разбор по шагам
  1. TCP_PORT = 8080 — на этом порту слушаем TCP.
  2. UDP_PORT = 9000 — на этом порту слушаем UDP.
  3. Executors.newFixedThreadPool(10) — создаём пул из 10 потоков. Все TCP-клиенты будут обслуживаться в этих потоках.
  4. new ServerSocket(TCP_PORT) — открываем TCP-порт.
  5. serverSocket.accept() — ждём клиента. Возвращает сокет клиента.
  6. POOL.submit(() -> handleTcpClient(client)) — отправляем задачу в пул. Не создаём новый поток, а переиспользуем один из 10.

Шаг 3: обработка TCP-клиента

Метод handleTcpClient принимает клиента, читает его сообщения и отправляет эхо-ответ.

private static void handleTcpClient(Socket client) { // Получаем IP клиента для лога String clientIp = client.getInetAddress().getHostAddress(); Logger.log("TCP-клиент подключился: " + clientIp); try ( // Поток для чтения от клиента BufferedReader in = new BufferedReader( new InputStreamReader(client.getInputStream())); // Поток для записи клиенту PrintWriter out = new PrintWriter( client.getOutputStream(), true) ) { // Таймаут: если клиент молчит 5 секунд — отключаем client.setSoTimeout(5000); String line; // Читаем строки, пока клиент не закроет соединение while ((line = in.readLine()) != null) { Logger.log("TCP от " + clientIp + ": " + line); // Отправляем эхо-ответ out.println("Эхо: " + line); } } catch (SocketTimeoutException e) { Logger.log("Таймаут для клиента " + clientIp); } catch (IOException e) { Logger.log("Ошибка с клиентом " + clientIp + ": " + e.getMessage()); } finally { // Обязательно закрываем сокет try { client.close(); } catch (IOException ignored) {} Logger.log("TCP-клиент отключился: " + clientIp); } }
Что происходит шаг за шагом
  1. Получаем IP клиента через client.getInetAddress().getHostAddress().
  2. Открываем BufferedReader для чтения и PrintWriter для записи.
  3. Устанавливаем таймаут setSoTimeout(5000) — 5 секунд.
  4. Читаем строки в цикле while.
  5. Каждую строку логируем и отправляем эхо-ответ.
  6. Если клиент молчит 5 секунд — SocketTimeoutException.
  7. В finally закрываем сокет — даже если была ошибка.
finally — блок, который выполнится всегда. Даже если была ошибка. Здесь мы закрываем сокет, чтобы не было «утечки» ресурсов.

Шаг 4: UDP-сервер

Теперь UDP-сервер. Он принимает пакеты и отправляет их обратно.

public static void startUdpServer() { try (DatagramSocket socket = new DatagramSocket(UDP_PORT)) { Logger.log("UDP-сервер запущен на порту " + UDP_PORT); // Буфер для приёма пакетов byte[] buffer = new byte[1024]; while (true) { // Создаём пакет для приёма DatagramPacket packet = new DatagramPacket(buffer, buffer.length); // Ждём пакет (блокирующая операция) socket.receive(packet); // Превращаем байты в строку String message = new String( packet.getData(), 0, packet.getLength()); String clientIp = packet.getAddress().getHostAddress(); Logger.log("UDP от " + clientIp + ": " + message); // Отправляем эхо-ответ (тот же пакет обратно) socket.send(packet); } } catch (IOException e) { Logger.log("Ошибка UDP-сервера: " + e.getMessage()); } }
Разбор по шагам
  1. new DatagramSocket(UDP_PORT) — открываем UDP-порт 9000.
  2. byte[] buffer = new byte[1024] — буфер на 1024 байта.
  3. new DatagramPacket(buffer, buffer.length) — пакет, в который запишется принятое.
  4. socket.receive(packet) — ждём пакет.
  5. new String(packet.getData(), 0, packet.getLength()) — превращаем байты в строку. Важно: getLength(), а не buffer.length.
  6. socket.send(packet) — отправляем тот же пакет обратно. DatagramPacket уже содержит адрес и порт клиента.
packet.getLength() — это сколько реально пришло байтов. buffer.length — это размер буфера (1024). Если использовать buffer.length — получим 1024 байта, из которых 1000 — мусор.

Шаг 5: запуск обоих серверов

В классе MultiServer добавим метод, который запускает TCP и UDP в отдельных потоках.

Зачем в отдельных потоках?

Если запустить TCP и UDP в одном потоке — они будут работать по очереди. TCP-сервер «висит» на accept(), UDP-сервер «висит» на receive(). Одновременно они не смогут работать без многопоточности.

public static void startAll() { // Запускаем TCP в отдельном потоке new Thread(MultiServer::startTcpServer).start(); // Запускаем UDP в отдельном потоке new Thread(MultiServer::startUdpServer).start(); }
Что происходит шаг за шагом
  1. new Thread(...) — создаём новый поток.
  2. MultiServer::startTcpServer — ссылка на метод. Это то, что будет делать поток.
  3. .start() — запускаем поток.
  4. Первый поток запускает TCP-сервер.
  5. Второй поток запускает UDP-сервер.
  6. Оба работают одновременно.
Теперь сервер принимает и TCP, и UDP. Клиенты могут подключаться по любому протоколу.

Шаг 6: точка входа

Класс Main просто запускает сервер.

public class Main { public static void main(String[] args) { Logger.log("=== Запуск сервера ==="); MultiServer.startAll(); System.out.println("Сервер работает. Смотрите server.log"); } }
Что происходит
  1. Записываем в лог «Запуск сервера».
  2. Запускаем TCP и UDP в отдельных потоках.
  3. Выводим сообщение в консоль.
  4. Main завершается, но потоки продолжают работать. Программа не закрывается, пока работают хотя бы одни потоки.
Main — это только «кнопка запуска». Вся работа — в других классах. Это принцип разделения ответственности.

Шаг 7: TCP-клиент для проверки

Чтобы проверить TCP-сервер, нужен клиент.

import java.io.*; import java.net.*; public class TestTcpClient { public static void main(String[] args) throws Exception { // Подключаемся к серверу Socket socket = new Socket("localhost", 8080); // Потоки для чтения и записи BufferedReader in = new BufferedReader( new InputStreamReader(socket.getInputStream())); PrintWriter out = new PrintWriter(socket.getOutputStream(), true); // Отправляем сообщение out.println("Привет, сервер!"); // Читаем ответ String response = in.readLine(); System.out.println("Ответ сервера: " + response); socket.close(); } }
Что происходит шаг за шагом
  1. new Socket("localhost", 8080) — подключаемся к серверу на порт 8080.
  2. Открываем потоки для чтения и записи.
  3. Отправляем «Привет, сервер!».
  4. Сервер отвечает «Эхо: Привет, сервер!».
  5. Выводим ответ в консоль.
  6. Закрываем сокет.
В консоли увидите: «Ответ сервера: Эхо: Привет, сервер!». Сервер работает.

Шаг 8: UDP-клиент для проверки

Теперь клиент для UDP-сервера.

import java.net.*; public class TestUdpClient { public static void main(String[] args) throws Exception { // Создаём UDP-сокет DatagramSocket socket = new DatagramSocket(); // Адрес сервера InetAddress address = InetAddress.getByName("localhost"); // Отправляем пакет String message = "Привет по UDP!"; byte[] data = message.getBytes(); DatagramPacket packet = new DatagramPacket( data, data.length, address, 9000); socket.send(packet); // Ждём эхо-ответ byte[] buffer = new byte[1024]; DatagramPacket response = new DatagramPacket(buffer, buffer.length); socket.receive(response); // Выводим ответ String answer = new String( response.getData(), 0, response.getLength()); System.out.println("Ответ сервера: " + answer); socket.close(); } }
Что происходит шаг за шагом
  1. new DatagramSocket() — создаём UDP-сокет (порт выберется автоматически).
  2. Получаем адрес сервера.
  3. Создаём пакет с сообщением и адресом.
  4. Отправляем пакет.
  5. Готовим буфер для ответа.
  6. Ждём ответ через receive.
  7. Выводим ответ.
socket.receive(response) — блокирующий. Если сервер не ответит — клиент зависнет. Для учебного примера это нормально. В реальном проекте — добавьте таймаут.

Что будет в логе

После запуска сервера и клиентов файл server.log будет выглядеть примерно так:

[2026-11-15 14:30:00] === Запуск сервера === [2026-11-15 14:30:00] TCP-сервер запущен на порту 8080 [2026-11-15 14:30:00] UDP-сервер запущен на порту 9000 [2026-11-15 14:30:05] TCP-клиент подключился: 127.0.0.1 [2026-11-15 14:30:05] TCP от 127.0.0.1: Привет, сервер! [2026-11-15 14:30:05] TCP-клиент отключился: 127.0.0.1 [2026-11-15 14:30:10] UDP от 127.0.0.1: Привет по UDP!
Что видно в логе
  1. Время каждого события.
  2. Запуск серверов.
  3. IP клиентов, которые подключаются.
  4. Все сообщения, которые приходят.
  5. Отключения клиентов.
Лог — это «чёрный ящик» сервера. Если что-то сломалось — открываете файл и смотрите, что было.

Проверка работы

Как проверить, что всё работает.

Шаг 1. Запустить сервер

Запустите Main. В консоли увидите «Сервер работает. Смотрите server.log».

Шаг 2. Проверить TCP

Запустите TestTcpClient. В консоли увидите «Ответ сервера: Эхо: Привет, сервер!».

Шаг 3. Проверить UDP

Запустите TestUdpClient. В консоли увидите «Ответ сервера: Привет по UDP!».

Шаг 4. Открыть лог

Откройте файл server.log в папке проекта. Там будут все события.

Если всё работает — вы написали многопоточный сервер с TCP, UDP и логированием.

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

1. Порт занят
Ошибка BindException. Смените порт или закройте программы, которые его используют.
2. Забыли start()
Поток создан, но не запущен. Решение: thread.start(), а не thread.run().
3. Забыли synchronized в Logger
Два потока одновременно пишут в файл — данные перемешиваются. Решение: synchronized.
4. Использование buffer.length
В строке появляется мусор. Решение: packet.getLength().
5. Забыли setSoTimeout
Клиент «завис» — сервер ждёт вечно. Решение: таймаут.
6. Не обработали разрыв
Сервер падает с SocketException. Решение: try-catch.
7. Забыли закрыть сокет
Утечка ресурсов. Решение: try-with-resources или finally.

Задание для расширения

После того как базовый сервер работает, попробуйте улучшить его.

Задание 1. Подсчёт клиентов

Добавьте счётчик подключённых TCP-клиентов. Выводите его в лог при подключении и отключении.

Задание 2. Команда STATS

Если клиент отправляет «STATS», сервер возвращает количество обработанных сообщений.

Задание 3. Логирование в разные файлы

Сделайте отдельные файлы для TCP и UDP: tcp.log и udp.log.

Задание 4. Хранение сообщений

Сохраняйте все принятые сообщения в messages.txt.

Задания 1 и 2 — обязательны. Задания 3 и 4 — для оценки «отлично».

Полная структура проекта

Вот как выглядит проект целиком.

project/ ├── src/ │ └── ru/ │ └── gadget59/ │ └── server/ │ ├── Logger.java │ ├── MultiServer.java │ ├── Main.java │ ├── TestTcpClient.java │ └── TestUdpClient.java └── server.log // создастся автоматически
Что где лежит
  1. Logger — запись в файл.
  2. MultiServer — TCP и UDP серверы.
  3. Main — запуск сервера.
  4. TestTcpClient — тестовый TCP-клиент.
  5. TestUdpClient — тестовый UDP-клиент.
  6. server.log — создаётся автоматически.
Если проект на Maven — структура будет src/main/java/ru/gadget59/server/. Если без Maven — просто src/ru/gadget59/server/.

Шпаргалка

Сохраните этот слайд — всё, что нужно для практики.

ЗадачаКод TCP-серверnew ServerSocket(8080) Принять клиентаserverSocket.accept() Пул потоковExecutors.newFixedThreadPool(10) Запустить задачу в пулеpool.submit(() -> handle(client)) UDP-серверnew DatagramSocket(9000) Принять UDP-пакетsocket.receive(packet) Отправить UDP-пакетsocket.send(packet) Прочитать строкуnew String(packet.getData(), 0, packet.getLength()) Таймаутclient.setSoTimeout(5000) ЛогированиеLogger.log("сообщение")
Этих команд достаточно, чтобы повторить практику с нуля.

Итоги практики

Подведём итоги.

  • ✅ Logger — запись событий в файл с synchronized.
  • ✅ TCP-сервер на ServerSocket.
  • ✅ UDP-сервер на DatagramSocket.
  • ✅ Пул потоков ExecutorService для клиентов.
  • ✅ Таймауты через setSoTimeout.
  • ✅ Обработка разрыва через try-catch-finally.
  • ✅ Два сервера работают одновременно в разных потоках.
  • ✅ Логирование всех событий.
Вы написали настоящий многопоточный сетевой сервер. Это уровень junior-разработчика.

Домашнее задание

Задания для самостоятельной работы.

  1. Повторите практику с нуля: Logger, MultiServer, Main, TestTcpClient, TestUdpClient.
  2. Добавьте счётчик TCP-клиентов.
  3. Добавьте команду STATS для просмотра статистики.
  4. Разделите логирование на tcp.log и udp.log.
  5. Сохраняйте все сообщения в messages.txt.
  6. Добавьте таймаут на UDP-клиент, чтобы он не зависал.
Задания 1–3 обязательны. Задания 4–6 — для оценки «отлично».

Чек-лист

Что должно быть сделано.

✅
Logger
Пишет в файл с synchronized.
✅
TCP-сервер
Принимает клиентов, отправляет эхо.
✅
UDP-сервер
Принимает пакеты, отправляет эхо.
✅
Пул потоков
Клиенты обслуживаются в пуле.
✅
Таймауты
Клиент не «висит» вечно.
✅
Лог-файл
Все события записаны в server.log.
Если все пункты отмечены — практика выполнена полностью.

Что было самым сложным?

Подумайте и ответьте себе:

  • Что было непонятно в самом начале?
  • Что стало понятно после практики?
  • Какая часть больше всего понравилась?
  • Что хотите изучить глубже?
Рефлексия — важная часть обучения. Она помогает понять, что вы действительно усвоили, а что стоит повторить.
Если что-то осталось непонятным — вернитесь к слайдам лекции. Не бойтесь перечитывать.

Проверка результата

Что должно получиться:
  • Класс Logger с методом log(String).
  • Класс MultiServer с методами startTcpServer, startUdpServer, handleTcpClient, startAll.
  • Класс Main, который запускает сервер.
  • Класс TestTcpClient — тестовый TCP-клиент.
  • Класс TestUdpClient — тестовый UDP-клиент.
  • Файл server.log с логами всех событий.
  • TCP и UDP работают одновременно.
  • Таймауты и обработка разрыва реализованы.
Если всё это работает — практика выполнена на «отлично».

Что дальше?

Мы закончили блок «Сокеты». Куда двигаться?

  • Возврат к блоку «БД + JavaScript» — остались 2 лекции + 2 практики.
  • Закрыть пробелы методички — IDE, множества в Java, приложение с несколькими формами.
  • Новая тема — JavaFX, Git, HTTP/REST, Spring Boot.
Сокеты — это фундамент сетевого программирования. Дальше — специализация: backend, frontend или мобильная разработка.

Советы для дальнейшей работы

Несколько советов, которые пригодятся в будущем.

📖
Читайте ошибки
Java подробно описывает проблемы.
🧪
Пишите тесты
JUnit — стандарт тестирования.
🚀
Пробуйте новое
Каждый проект — опыт.
🤝
Советуйтесь
Программирование — командная работа.
Сетевые приложения — это то, что делает программирование по-настоящему интересным.

Резюме

Короткое резюме практики.

  • Logger — запись событий в файл с synchronized.
  • TCP-сервер — ServerSocket + Socket.
  • UDP-сервер — DatagramSocket + DatagramPacket.
  • Пул потоков — ExecutorService для TCP-клиентов.
  • Таймауты — setSoTimeout.
  • Обработка разрыва — try-catch-finally.
Эти шесть компонентов — минимальный набор для любого сетевого сервера.

Спасибо за работу!

📡

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

Вы написали TCP и UDP серверы, которые работают одновременно, логируют события, обрабатывают таймауты и разрывы. Это уровень junior-разработчика.

📡 UDP 🔗 TCP 🧵 Потоки 📝 Логи 🚀 сеть