Что такое TCP протокол?

TCP протокол (Transmission Control Protocol)

TCP — это одна из самых важных технологий в интернете и backend-разработке. Это протокол транспортного уровня (Layer 4 в OSI модели), который обеспечивает надёжную, упорядоченную доставку данных между приложениями на разных хостах.

Основные характеристики

Надёжность и упорядоченность

TCP гарантирует:

• Все данные доставляются полностью (нет потери пакетов)
• Данные приходят в том же порядке, в котором они были отправлены
• Дублирующиеся пакеты автоматически удаляются

// Приложение пишет в TCP:
int data[] = {1, 2, 3, 4, 5};
send(socket, data, sizeof(data), 0);

// Приложение гарантирует получит [1, 2, 3, 4, 5]
// Даже если низкоуровневые пакеты потеряны

Соединение (Connection-oriented)

Перед передачей данных устанавливается соединение (three-way handshake):

Клиент                          Сервер
   |
   |--- SYN (seq=x) ------------>|
   |                              |
   |<---- SYN-ACK (seq=y) --------|
   |                              |
   |--- ACK (seq=x+1) ----------->|
   |                              |
   |------- Данные ---------->    |

Как это работает технически

Управление потоком (Flow Control)

ТCP использует окно скольжения (sliding window) для контроля скорости передачи:

// Отправитель может отправить только столько данных,
// сколько приёмник может буферизировать

// Если буфер приёмника переполнен, отправитель замораживается
while (bytes_sent < total_bytes) {
    int window_size = get_receiver_window();
    int to_send = std::min(window_size, remaining_bytes);
    send(socket, buffer, to_send, 0);
    bytes_sent += to_send;
}

Подтверждение (Acknowledgment)

Каждый полученный пакет должен быть подтверждён:

Отправитель отправляет пакет с seq=100, data=hello
Приёмник отправляет ACK с ack=105 (100 + длина данных)

Если ACK не пришёл в течение timeout'а, пакет переотправляется (retransmission).

Управление перегрузкой (Congestion Control)

ТCP адаптирует скорость передачи к состоянию сети:

- Медленный старт (slow start)
- Избежание перегрузки (congestion avoidance)
- Быстрое восстановление (fast recovery)

Использование в C/C++

Создание TCP сокета (Linux)

#include <sys/socket.h>
#include <netinet/in.h>
#include <unistd.h>

int sock = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
if (sock < 0) {
    perror("socket");
    return -1;
}

Сервер (слушание на порту)

struct sockaddr_in server_addr;
server_addr.sin_family = AF_INET;
server_addr.sin_port = htons(8080);
server_addr.sin_addr.s_addr = INADDR_ANY;

bind(sock, (struct sockaddr*)&server_addr, sizeof(server_addr));
listen(sock, SOMAXCONN);

// Принять соединение
struct sockaddr_in client_addr;
socklen_t client_addr_len = sizeof(client_addr);
int client_sock = accept(sock, (struct sockaddr*)&client_addr, &client_addr_len);

// Получить данные
char buffer[1024];
int bytes = recv(client_sock, buffer, sizeof(buffer), 0);

Клиент (подключение к серверу)

struct sockaddr_in server_addr;
server_addr.sin_family = AF_INET;
server_addr.sin_port = htons(8080);
inet_pton(AF_INET, "127.0.0.1", &server_addr.sin_addr);

if (connect(sock, (struct sockaddr*)&server_addr, sizeof(server_addr)) < 0) {
    perror("connect");
    return -1;
}

// Отправить данные
const char* msg = "Hello, Server!";
send(sock, msg, strlen(msg), 0);

TCP vs UDP

Оптимизации для backend

TCP_NODELAY (отключение алгоритма Nagle)

int flag = 1;
setsockopt(sock, IPPROTO_TCP, TCP_NODELAY, &flag, sizeof(flag));
// Отправляет маленькие пакеты немедленно, не ждёт полного буфера

SO_REUSEADDR (переиспользование порта)

int reuse = 1;
setsockopt(sock, SOL_SOCKET, SO_REUSEADDR, &reuse, sizeof(reuse));
// Позволяет перезапустить сервер без ожидания TIME_WAIT

SO_KEEPALIVE (контроль живого соединения)

int keepalive = 1;
setsockopt(sock, SOL_SOCKET, SO_KEEPALIVE, &keepalive, sizeof(keepalive));
// Отправляет периодические пакеты для проверки живого соединения

Когда использовать TCP

• HTTP/HTTPS (веб)
• SMTP (почта)
• SSH (удалённый доступ)
• FTP (передача файлов)
• Любые приложения, где важна надёжность доставки

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