TCP UDP KCP对比

概念和特性
TCP（Transmission Control Protocol）
TCP（传输控制协议）是一种面向连接、可靠的传输层协议。它确保数据包按顺序无误地传递到目标地址，主要特性包括：

连接导向：在传输数据前必须建立连接（三次握手）。
可靠传输：通过序列号和确认应答机制确保数据传输的可靠性。
流量控制：通过滑动窗口机制实现流量控制。
拥塞控制：使用算法（如慢启动、拥塞避免、快速重传和快速恢复）防止网络拥塞。
UDP（User Datagram Protocol）
UDP（用户数据报协议）是一种无连接、不可靠的传输层协议。它不保证数据包的顺序和完整性，主要特性包括：

无连接：不需要建立连接就可以传输数据。
不可靠传输：不保证数据包的到达和顺序。
低延迟：由于没有复杂的控制机制，传输延迟低，适用于实时应用。
简单：头部开销小，处理速度快。
KCP
KCP 是一种基于 UDP 实现的传输协议，旨在提高 UDP 传输的可靠性和效率。主要特性包括：

快速重传：通过滑动窗口和快速重传机制提高传输效率。
低延迟：利用 UDP 的低延迟特性，适用于实时应用。
可靠传输：实现可靠的数据传输，避免数据包丢失。
流量控制：类似于 TCP 的流量控制机制。
区别和优点
TCP：可靠传输，保证数据完整性和顺序性，适用于文件传输、电子邮件等需要可靠传输的场景。但由于控制机制复杂，延迟较高。
UDP：无连接、不可靠但低延迟，适用于实时视频、音频传输、在线游戏等对实时性要求高的场景。
KCP：结合了 TCP 和 UDP 的优点，提供可靠的低延迟传输，适用于需要可靠性和实时性的场景，如实时通信、在线游戏等。
 

对比表
特性/协议    TCP    UDP    KCP
连接类型    面向连接（需要建立连接）    无连接（无需建立连接）    无连接（基于 UDP）
传输可靠性    高（保证数据包按序到达且无误）    低（不保证数据包的到达和顺序）    高（通过 ARQ 机制实现可靠传输）
传输延迟    高（由于连接建立、流量控制和拥塞控制）    低（无连接和控制机制）    低（通过 UDP 传输，同时实现可靠性）
流量控制    有（滑动窗口）    无    有（滑动窗口）
拥塞控制    有（慢启动、拥塞避免等算法）    无    有（基于 UDP 的实现，降低拥塞概率）
头部开销    大（20 字节的头部）    小（8 字节的头部）    中等（结合了 TCP 的可靠性机制）
应用场景    文件传输、电子邮件、网页浏览等    实时视频、音频传输、在线游戏等    实时通信、在线游戏、需要可靠性和低延迟的应用
 TCP 连接建立和传输过程
Client                       Server
  |                                      |
  | --------- SYN ------------> | 
  |                                        |
  | <------ SYN/ACK ----------- |
  |                                          |
  | --------- ACK ----------------> |
  |                                            |
  | ----- Data Transmission --->|
  |                                             |
  | <---- Acknowledgment -------|
  |                                              |

UDP 数据传输过程
Client                       Server
  |                             |
  | ----- Data Transmission --->|
  |                             |
  | <---- No Acknowledgment ----|
  |                             |
  | ----- Data Transmission --->|
  |                             |

KCP 数据传输过程
Client                       Server
  |                             |
  | ----- Data Transmission --->|
  |                             |
  | <---- Acknowledgment -------|
  |                             |
  | ----- Data Transmission --->|
  |                             |
  | <---- Acknowledgment -------|
  |                             |
 

 TCP 客户端和服务端
服务端
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <unistd.h>
#include <arpa/inet.h>
 
#define PORT 8080
 
int main() {
    int server_fd, new_socket;
    struct sockaddr_in address;
    int opt = 1;
    int addrlen = sizeof(address);
    char buffer[1024] = {0};
    char *hello = "Hello from server";
 
    if ((server_fd = socket(AF_INET, SOCK_STREAM, 0)) == 0) {
        perror("socket failed");
        exit(EXIT_FAILURE);
    }
 
    if (setsockopt(server_fd, SOL_SOCKET, SO_REUSEADDR | SO_REUSEPORT, &opt, sizeof(opt))) {
        perror("setsockopt");
        exit(EXIT_FAILURE);
    }
 
    address.sin_family = AF_INET;
    address.sin_addr.s_addr = INADDR_ANY;
    address.sin_port = htons(PORT);
 
    if (bind(server_fd, (struct sockaddr *)&address, sizeof(address)) < 0) {
        perror("bind failed");
        exit(EXIT_FAILURE);
    }
 
    if (listen(server_fd, 3) < 0) {
        perror("listen");
        exit(EXIT_FAILURE);
    }
 
    if ((new_socket = accept(server_fd, (struct sockaddr *)&address, (socklen_t*)&addrlen)) < 0) {
        perror("accept");
        exit(EXIT_FAILURE);
    }
 
    read(new_socket, buffer, 1024);
    printf("Message from client: %s\n", buffer);
    send(new_socket, hello, strlen(hello), 0);
    printf("Hello message sent\n");
 
    close(new_socket);
    close(server_fd);
    return 0;
}

客户端 
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <unistd.h>
#include <arpa/inet.h>
 
#define PORT 8080
 
int main() {
    struct sockaddr_in address;
    int sock = 0, valread;
    struct sockaddr_in serv_addr;
    char *hello = "Hello from client";
    char buffer[1024] = {0};
 
    if ((sock = socket(AF_INET, SOCK_STREAM, 0)) < 0) {
        printf("\n Socket creation error \n");
        return -1;
    }
 
    serv_addr.sin_family = AF_INET;
    serv_addr.sin_port = htons(PORT);
 
    if (inet_pton(AF_INET, "127.0.0.1", &serv_addr.sin_addr) <= 0) {
        printf("\nInvalid address/ Address not supported \n");
        return -1;
    }
 
    if (connect(sock, (struct sockaddr *)&serv_addr, sizeof(serv_addr)) < 0) {
        printf("\nConnection Failed \n");
        return -1;
    }
 
    send(sock, hello, strlen(hello), 0);
    printf("Hello message sent\n");
    valread = read(sock, buffer, 1024);
    printf("Message from server: %s\n", buffer);
 
    close(sock);
    return 0;
}

UDP 客户端和服务端
服务端
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <unistd.h>
#include <arpa/inet.h>
 
#define PORT 8080
 
int main() {
    int sockfd;
    char buffer[1024];
    char *hello = "Hello from server";
    struct sockaddr_in servaddr, cliaddr;
 
    if ((sockfd = socket(AF_INET, SOCK_DGRAM, 0)) < 0) {
        perror("socket creation failed");
        exit(EXIT_FAILURE);
    }
 
    memset(&servaddr, 0, sizeof(servaddr));
    memset(&cliaddr, 0, sizeof(cliaddr));
 
    servaddr.sin_family = AF_INET;
    servaddr.sin_addr.s_addr = INADDR_ANY;
    servaddr.sin_port = htons(PORT);
 
    if (bind(sockfd, (const struct sockaddr *)&servaddr, sizeof(servaddr)) < 0) {
        perror("bind failed");
        exit(EXIT_FAILURE);
    }
 
    int len, n;
    len = sizeof(cliaddr);
 
    n = recvfrom(sockfd, buffer, 1024, MSG_WAITALL, (struct sockaddr *)&cliaddr, &len);
    buffer[n] = '\0';
    printf("Message from client: %s\n", buffer);
    sendto(sockfd, hello, strlen(hello), MSG_CONFIRM, (const struct sockaddr *)&cliaddr, len);
    printf("Hello message sent\n");
 
    close(sockfd);
    return 0;
}

客户端
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <unistd.h>
#include <arpa/inet.h>
 
#define PORT 8080
 
int main() {
    int sockfd;
    char buffer[1024];
    char *hello = "Hello from client";
    struct sockaddr_in servaddr;
 
    if ((sockfd = socket(AF_INET, SOCK_DGRAM, 0)) < 0) {
        perror("socket creation failed");
        exit(EXIT_FAILURE);
    }
 
    memset(&servaddr, 0, sizeof(servaddr));
 
    servaddr.sin_family = AF_INET;
    servaddr.sin_port = htons(PORT);
    servaddr.sin_addr.s_addr = INADDR_ANY;
 
    int n, len;
 
    sendto(sockfd, hello, strlen(hello), MSG_CONFIRM, (const struct sockaddr *)&servaddr, sizeof(servaddr));
    printf("Hello message sent\n");
 
    n = recvfrom(sockfd, buffer, 1024, MSG_WAITALL, (struct sockaddr *)&servaddr, &len);
    buffer[n] = '\0';
    printf("Message from server: %s\n", buffer);
 
    close(sockfd);
    return 0;
}

KCP 客户端和服务端
KCP 的实现相对复杂，通常需要借助第三方库来实现。以下代码示例基于 KCP 官方提供的 C 库 ikcp 实现。
服务端
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <arpa/inet.h>
#include "ikcp.h"
 
#define PORT 8080
 
int udp_output(const char *buf, int len, ikcpcb *kcp, void *user) {
    int sockfd = *(int *)user;
    struct sockaddr_in *cliaddr = (struct sockaddr_in *)kcp->user;
    sendto(sockfd, buf, len, 0, (const struct sockaddr *)cliaddr, sizeof(*cliaddr));
    return 0;
}
 
int main() {
    int sockfd;
    char buffer[1024];
    struct sockaddr_in servaddr, cliaddr;
    int len, n;
 
    if ((sockfd = socket(AF_INET, SOCK_DGRAM, 0)) < 0) {
        perror("socket creation failed");
        exit(EXIT_FAILURE);
    }
 
    memset(&servaddr, 0, sizeof(servaddr));
    memset(&cliaddr, 0, sizeof(cliaddr));
 
    servaddr.sin_family = AF_INET;
    servaddr.sin_addr.s_addr = INADDR_ANY;
    servaddr.sin_port = htons(PORT);
 
    if (bind(sockfd, (const struct sockaddr *)&servaddr, sizeof(servaddr)) < 0) {
        perror("bind failed");
        exit(EXIT_FAILURE);
    }
 
    len = sizeof(cliaddr);
    n = recvfrom(sockfd, buffer, 1024, MSG_WAITALL, (struct sockaddr *)&cliaddr, &len);
    buffer[n] = '\0';
 
    ikcpcb *kcp = ikcp_create(0x11223344, (void *)&cliaddr);
    kcp->output = udp_output;
    kcp->user = &sockfd;
 
    ikcp_input(kcp, buffer, n);
 
    while (1) {
        usleep(10000);
        ikcp_update(kcp, iclock());
 
        n = recvfrom(sockfd, buffer, 1024, MSG_DONTWAIT, (struct sockaddr *)&cliaddr, &len);
        if (n > 0) {
            ikcp_input(kcp, buffer, n);
        }
 
        while (1) {
            n = ikcp_recv(kcp, buffer, 1024);
            if (n < 0) break;
            printf("Message from client: %s\n", buffer);
            ikcp_send(kcp, "Hello from server", 17);
        }
    }
 
    ikcp_release(kcp);
    close(sockfd);
    return 0;
}
客户端
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <arpa/inet.h>
#include "ikcp.h"
 
#define PORT 8080
 
int udp_output(const char *buf, int len, ikcpcb *kcp, void *user) {
    int sockfd = *(int *)user;
    struct sockaddr_in *servaddr = (struct sockaddr_in *)kcp->user;
    sendto(sockfd, buf, len, 0, (const struct sockaddr *)servaddr, sizeof(*servaddr));
    return 0;
}
 
int main() {
    int sockfd;
    char buffer[1024];
    struct sockaddr_in servaddr;
    int len, n;
 
    if ((sockfd = socket(AF_INET, SOCK_DGRAM, 0)) < 0) {
        perror("socket creation failed");
        exit(EXIT_FAILURE);
    }
 
    memset(&servaddr, 0, sizeof(servaddr));
 
    servaddr.sin_family = AF_INET;
    servaddr.sin_port = htons(PORT);
    servaddr.sin_addr.s_addr = inet_addr("127.0.0.1");
 
    ikcpcb *kcp = ikcp_create(0x11223344, (void *)&servaddr);
    kcp->output = udp_output;
    kcp->user = &sockfd;
 
    ikcp_send(kcp, "Hello from client", 17);
 
    while (1) {
        usleep(10000);
        ikcp_update(kcp, iclock());
 
        len = sizeof(servaddr);
        n = recvfrom(sockfd, buffer, 1024, MSG_DONTWAIT, (struct sockaddr *)&servaddr, &len);
        if (n > 0) {
            ikcp_input(kcp, buffer, n);
        }
 
        while (1) {
            n = ikcp_recv(kcp, buffer, 1024);
            if (n < 0) break;
            printf("Message from server: %s\n", buffer);
        }
    }
 
    ikcp_release(kcp);
    close(sockfd);
    return 0;
}
结论
TCP、UDP 和 KCP 各有其独特的特性和应用场景。TCP 提供可靠的数据传输，适用于需要高可靠性的应用。UDP 提供低延迟的传输，适用于实时性要求高的应用。KCP 则结合了两者的优点，在保证低延迟的同时提供可靠的数据传输，适用于需要实时性和可靠性的应用。根据不同的应用需求选择合适的传输协议，可以提高应用的性能和用户体验。