MENU
未来を創るコードと共に、成長するエンジニアへ
  1. ホーム
  2. プログラミング言語比較
  3. 中級
  4. TCPソケットとUDPソケットの違いと選択方法

TCPソケットとUDPソケットの違いと選択方法

中級
tcp-udp-socket

TCPとUDPは、インターネット上の通信を行う際に使用される2つの主要なプロトコルです。それぞれに利点と欠点があり、使用するアプリケーションや要件に応じて適切なものを選択することが重要です。この記事では、TCPとUDPの違いを明確にし、どのような状況でどちらのプロトコルを選択すべきかについて解説します。

目次

基本概念の説明

  • TCP (Transmission Control Protocol): TCPは接続指向のプロトコルで、信頼性が高く、送受信データの順序やエラーのチェックを行います。これにより、データが確実に相手に届くことを保証します。ファイル転送やウェブページの閲覧など、正確なデータ転送が必要なアプリケーションに最適です。
  • UDP (User Datagram Protocol): UDPは非接続型プロトコルで、データの到達や順序の保証を行わず、送信したデータが受信者に確実に届くことは保証されません。リアルタイム通信やストリーミング、オンラインゲームなど、多少のデータ損失が許容されるが速度が重視されるアプリケーションに向いています。

TCP と UDP の違い

特徴TCPUDP
接続性接続型（コネクションを確立する必要がある）非接続型（コネクションを確立せずにデータを送信）
信頼性高い（データの順序と正確な到達を保証）低い（データの順序や到達を保証しない）
データ伝送ストリームとして伝送データグラムとして伝送
速度比較的遅い（接続確立やエラーチェックのため）高速（エラー処理がないため）
使用例ウェブブラウジング、メール送信、ファイル転送ビデオストリーミング、オンラインゲーム、VoIP

各言語でのサンプルコード

Python: TCPソケットとUDPソケット

TCPソケット


# Python TCP サーバープログラム
import socket

server_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
server_socket.bind(('localhost', 12345))
server_socket.listen(1)
print("Waiting for a TCP connection...")

conn, addr = server_socket.accept()
print(f"Connection from {addr}")

data = conn.recv(1024).decode()
print(f"Received data: {data}")

conn.send("Hello from TCP server".encode())
conn.close()

# Python TCP クライアントプログラム
import socket

client_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
client_socket.connect(('localhost', 12345))

client_socket.send("Hello from TCP client".encode())
response = client_socket.recv(1024).decode()
print(f"Received from server: {response}")

client_socket.close()

UDPソケット


# Python UDP サーバープログラム
import socket

server_socket = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
server_socket.bind(('localhost', 12345))
print("UDP server is ready")

while True:
    data, addr = server_socket.recvfrom(1024)
    print(f"Received message: {data.decode()} from {addr}")
    server_socket.sendto("Hello from UDP server".encode(), addr)

# Python UDP クライアントプログラム
import socket

client_socket = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
client_socket.sendto("Hello from UDP client".encode(), ('localhost', 12345))

data, addr = client_socket.recvfrom(1024)
print(f"Received from server: {data.decode()}")
client_socket.close()

C#: TCPソケットとUDPソケット

TCPソケット


// C# TCP サーバープログラム
using System;
using System.Net;
using System.Net.Sockets;
using System.Text;

class TcpServer
{
    static void Main()
    {
        TcpListener server = new TcpListener(IPAddress.Parse("127.0.0.1"), 12345);
        server.Start();
        Console.WriteLine("Waiting for a TCP connection...");

        TcpClient client = server.AcceptTcpClient();
        NetworkStream stream = client.GetStream();

        byte[] buffer = new byte[1024];
        int bytesRead = stream.Read(buffer, 0, buffer.Length);
        string data = Encoding.ASCII.GetString(buffer, 0, bytesRead);
        Console.WriteLine($"Received data: {data}");

        byte[] response = Encoding.ASCII.GetBytes("Hello from TCP server");
        stream.Write(response, 0, response.Length);
        client.Close();
        server.Stop();
    }
}

// C# TCP クライアントプログラム
using System;
using System.Net.Sockets;
using System.Text;

class TcpClientApp
{
    static void Main()
    {
        TcpClient client = new TcpClient("127.0.0.1", 12345);
        NetworkStream stream = client.GetStream();

        byte[] data = Encoding.ASCII.GetBytes("Hello from TCP client");
        stream.Write(data, 0, data.Length);

        byte[] buffer = new byte[1024];
        int bytesRead = stream.Read(buffer, 0, buffer.Length);
        string response = Encoding.ASCII.GetString(buffer, 0, bytesRead);
        Console.WriteLine($"Received from server: {response}");

        client.Close();
    }
}

UDPソケット


// C# UDP サーバープログラム
using System;
using System.Net;
using System.Net.Sockets;
using System.Text;

class UdpServer
{
    static void Main()
    {
        UdpClient server = new UdpClient(12345);
        IPEndPoint clientEndpoint = new IPEndPoint(IPAddress.Any, 0);
        Console.WriteLine("UDP server is ready");

        while (true)
        {
            byte[] data = server.Receive(ref clientEndpoint);
            Console.WriteLine($"Received message: {Encoding.ASCII.GetString(data)} from {clientEndpoint}");
            byte[] response = Encoding.ASCII.GetBytes("Hello from UDP server");
            server.Send(response, response.Length, clientEndpoint);
        }
    }
}

// C# UDP クライアントプログラム
using System;
using System.Net;
using System.Net.Sockets;
using System.Text;

class UdpClientApp
{
    static void Main()
    {
        UdpClient client = new UdpClient();
        byte[] data = Encoding.ASCII.GetBytes("Hello from UDP client");
        client.Send(data, data.Length, "localhost", 12345);

        IPEndPoint serverEndpoint = new IPEndPoint(IPAddress.Any, 0);
        byte[] response = client.Receive(ref serverEndpoint);
        Console.WriteLine($"Received from server: {Encoding.ASCII.GetString(response)}");
        client.Close();
    }
}

C++: TCPソケットとUDPソケット

TCPソケット


// C++ TCP サーバープログラム
#include <iostream>
#include <string>
#include <sys/socket.h>
#include <netinet/in.h>
#include <unistd.h>

int main() {
    int server_fd = socket(AF_INET, SOCK_STREAM, 0);
    sockaddr_in address = {AF_INET, htons(12345), INADDR_ANY};

    bind(server_fd, (sockaddr*)&address, sizeof(address));
    listen(server_fd, 1);
    std::cout << "Waiting for a TCP connection..." << std::endl;

    int client_fd = accept(server_fd, nullptr, nullptr);
    char buffer[1024] = {0};
    read(client_fd, buffer, 1024);
    std::cout << "Received data: " << buffer << std::endl;

    std::string response = "Hello from TCP server";
    send(client_fd, response.c_str(), response.length(), 0);
    close(client_fd);
    close(server_fd);
}

// C++ TCP クライアントプログラム
#include <iostream>
#include <string>
#include <sys/socket.h>
#include <arpa/inet.h>
#include <unistd.h>

int main() {
    int client_fd = socket(AF_INET, SOCK_STREAM, 0);
    sockaddr_in server_address = {AF_INET, htons(12345), inet_addr("127.0.0.1")};

    connect(client_fd, (sockaddr*)&server_address, sizeof(server_address));

    std::string message = "Hello from TCP client";
    send(client_fd, message.c_str(), message.length(), 0);

    char buffer[1024] = {0};
    read(client_fd, buffer, 1024);
    std::cout << "Received from server: " << buffer << std::endl;

    close(client_fd);
}

UDPソケット


// C++ UDP サーバープログラム
#include <iostream>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <unistd.h>

int main() {
    int server_fd = socket(AF_INET, SOCK_DGRAM, 0);
    sockaddr_in server_addr = {AF_INET, htons(12345), INADDR_ANY};

    bind(server_fd, (sockaddr*)&server_addr, sizeof(server_addr));
    std::cout << "UDP server is ready" << std::endl;

    char buffer[1024];
    sockaddr_in client_addr;
    socklen_t client_addr_len = sizeof(client_addr);

    while (true) {
        int len = recvfrom(server_fd, buffer, 1024, 0, (sockaddr*)&client_addr, &client_addr_len);
        std::cout << "Received message: " << buffer << std::endl;
        sendto(server_fd, "Hello from UDP server", 21, 0, (sockaddr*)&client_addr, client_addr_len);
    }

    close(server_fd);
}

// C++ UDP クライアントプログラム
#include <iostream>
#include <sys/socket.h>
#include <arpa/inet.h>
#include <unistd.h>

int main() {
    int client_fd = socket(AF_INET, SOCK_DGRAM, 0);
    sockaddr_in server_addr = {AF_INET, htons(12345), inet_addr("127.0.0.1")};

    std::string message = "Hello from UDP client";
    sendto(client_fd, message.c_str(), message.length(), 0, (sockaddr*)&server_addr, sizeof(server_addr));

    char buffer[1024];
    socklen_t server_addr_len = sizeof(server_addr);
    recvfrom(client_fd, buffer, 1024, 0, (sockaddr*)&server_addr, &server_addr_len);
    std::cout << "Received from server: " << buffer << std::endl;

    close(client_fd);
}

Java: TCPソケットとUDPソケット

TCPソケット


// Java TCP サーバープログラム
import java.io.*;
import java.net.*;

public class TcpServer {
    public static void main(String[] args) throws IOException {
        ServerSocket serverSocket = new ServerSocket(12345);
        System.out.println("Waiting for a TCP connection...");

        Socket clientSocket = serverSocket.accept();
        BufferedReader in = new BufferedReader(new InputStreamReader(clientSocket.getInputStream()));
        PrintWriter out = new PrintWriter(clientSocket.getOutputStream(), true);

        String data = in.readLine();
        System.out.println("Received data: " + data);

        out.println("Hello from TCP server");
        clientSocket.close();
        serverSocket.close();
    }
}

// Java TCP クライアントプログラム
import java.io.*;
import java.net.*;

public class TcpClient {
    public static void main(String[] args) throws IOException {
        Socket clientSocket = new Socket("127.0.0.1", 12345);
        PrintWriter out = new PrintWriter(clientSocket.getOutputStream(), true);
        BufferedReader in = new BufferedReader(new InputStreamReader(clientSocket.getInputStream()));

        out.println("Hello from TCP client");
        String response = in.readLine();
        System.out.println("Received from server: " + response);

        clientSocket.close();
    }
}

UDPソケット


// Java UDP サーバープログラム
import java.net.*;

public class UdpServer {
    public static void main(String[] args) throws Exception {
        DatagramSocket serverSocket = new DatagramSocket(12345);
        byte[] receiveData = new byte[1024];
        System.out.println("UDP server is ready");

        while (true) {
            DatagramPacket receivePacket = new DatagramPacket(receiveData, receiveData.length);
            serverSocket.receive(receivePacket);
            String message = new String(receivePacket.getData(), 0, receivePacket.getLength());
            System.out.println("Received message: " + message);

            String response = "Hello from UDP server";
            DatagramPacket sendPacket = new DatagramPacket(response.getBytes(), response.length(),
                    receivePacket.getAddress(), receivePacket.getPort());
            serverSocket.send(sendPacket);
        }
    }
}

// Java UDP クライアントプログラム
import java.net.*;

public class UdpClient {
    public static void main(String[] args) throws Exception {
        DatagramSocket clientSocket = new DatagramSocket();
        InetAddress serverAddress = InetAddress.getByName("localhost");

        String message = "Hello from UDP client";
        byte[] sendData = message.getBytes();
        DatagramPacket sendPacket = new DatagramPacket(sendData, sendData.length, serverAddress, 12345);
        clientSocket.send(sendPacket);

        byte[] receiveData = new byte[1024];
        DatagramPacket receivePacket = new DatagramPacket(receiveData, receiveData.length);
        clientSocket.receive(receivePacket);
        String response = new String(receivePacket.getData(), 0, receivePacket.getLength());
        System.out.println("Received from server: " + response);
        clientSocket.close();
    }
}

JavaScript: TCPソケットとUDPソケット

TCPソケット


// Node.js TCP サーバープログラム
const net = require('net');
const server = net.createServer((socket) => {
    console.log('Client connected');

    socket.on('data', (data) => {
        console.log(`Received data: ${data}`);
        socket.write('Hello from TCP server');
    });

    socket.on('end', () => {
        console.log('Client disconnected');
    });
});

server.listen(12345, () => {
    console.log('Server is listening on port 12345');
});

// Node.js TCP クライアントプログラム
const net = require('net');
const client = net.createConnection({ port: 12345 }, () => {
    console.log('Connected to TCP server');
    client.write('Hello from TCP client');
});

client.on('data', (data) => {
    console.log(`Received from server: ${data}`);
    client.end();
});

client.on('end', () => {
    console.log('Disconnected from TCP server');
});

UDPソケット


// Node.js UDP サーバープログラム
const dgram = require('dgram');
const server = dgram.createSocket('udp4');

server.on('message', (msg, rinfo) => {
    console.log(`Received message: ${msg} from ${rinfo.address}:${rinfo.port}`);
    server.send('Hello from UDP server', rinfo.port, rinfo.address);
});

server.bind(12345, () => {
    console.log('UDP server is ready');
});

// Node.js UDP クライアントプログラム
const dgram = require('dgram');
const client = dgram.createSocket('udp4');

client.send('Hello from UDP client', 12345, 'localhost', (err) => {
    if (err) console.error(err);
});

client.on('message', (msg) => {
    console.log(`Received from server: ${msg}`);
    client.close();
});

TCPとUDPの選択方法

TCPとUDPのどちらを選ぶべきかは、アプリケーションの要件に依存します。

UDPを選択するケース: リアルタイム性が重視され、少量のデータ損失が許容される場合（例：ビデオストリーミング、オンラインゲーム、音声通話）

TCPを選択するケース: データの正確性が重要な場合、信頼性が必要な通信（例：ウェブサイトの閲覧、ファイル転送、メール）

まとめ

TCPは信頼性と正確性が求められる場合に使用され、UDPは速度が重要なリアルタイムアプリケーションに適しています。各プロトコルの特徴を理解し、適切な用途で選択することが重要です。ログラミングのテクニックについて学んでいきましょう。

中級
Python プログラミング ネットワーク 通信 信頼性 TCPソケット UDPソケット 速度
よかったらシェアしてね！
  • URLをコピーしました！
  • URLをコピーしました！

コメント

コメントする

目次