当前位置： 首页 > article >正文

Java网络编程之UDP协议介绍及示例代码

article 2025/1/5 17:20:59

UDP（User Datagram Protocol）是一种无连接的协议，它在发送数据之前不需要建立连接，因此传输速度较快，但可靠性不如TCP。在Java中，可以使用DatagramSocket和DatagramPacket类来实现UDP通信。

UDP的基本概念

  • ‌无连接‌：UDP在发送数据之前不需要建立连接，因此可以快速地发送数据。
  • ‌不可靠‌：UDP不保证数据的完整性和顺序，可能会出现数据丢失、重复或乱序的情况。
  • ‌面向数据报‌：UDP将应用层的数据封装成一个个的数据报（Datagram），每个数据报都有独立的头部和数据部分。

Java中UDP编程的基本步骤

  1. ‌创建发送端‌：

    • 创建一个DatagramSocket对象，指定发送端的端口号。
    • 创建一个DatagramPacket对象，将需要发送的数据封装到该对象中，并指定接收端的IP地址和端口号。
    • 调用DatagramSocket对象的send()方法发送数据报。

  2. ‌创建接收端‌：

    • 创建一个DatagramSocket对象，指定接收端的端口号。
    • 创建一个空的DatagramPacket对象，用于接收数据报。该对象需要指定一个字节数组来存储接收到的数据，以及该数组的长度。
    • 调用DatagramSocket对象的receive()方法接收数据报。该方法会阻塞，直到接收到一个数据报为止。
    • 从接收到的DatagramPacket对象中获取数据，并处理。

UDP通信示例

以下是一个简单的UDP通信示例，包括发送端和接收端的实现。

发送端代码
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetAddress;

public class UDPSender {
    public static void main(String[] args) {
        DatagramSocket socket = null;
        try {
            // 创建DatagramSocket对象，指定发送端的端口号
            socket = new DatagramSocket();
            
            // 指定接收端的IP地址和端口号
            InetAddress address = InetAddress.getByName("localhost");
            int port = 9876;
            
            // 创建DatagramPacket对象，封装需要发送的数据
            String message = "Hello, UDP!";
            byte[] buffer = message.getBytes();
            DatagramPacket packet = new DatagramPacket(buffer, buffer.length, address, port);
            
            // 发送数据报
            socket.send(packet);
            
            System.out.println("Message sent: " + message);
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            // 关闭DatagramSocket对象
            if (socket != null && !socket.isClosed()) {
                socket.close();
            }
        }
    }
}
接收端代码
import java.net.DatagramPacket;
import java.net.DatagramSocket;

public class UDPReceiver {
    public static void main(String[] args) {
        DatagramSocket socket = null;
        try {
            // 创建DatagramSocket对象，指定接收端的端口号
            socket = new DatagramSocket(9876);
            
            // 创建一个空的DatagramPacket对象，用于接收数据报
            byte[] buffer = new byte[1024];
            DatagramPacket packet = new DatagramPacket(buffer, buffer.length);
            
            // 接收数据报
            socket.receive(packet);
            
            // 从接收到的DatagramPacket对象中获取数据，并处理
            String message = new String(packet.getData(), 0, packet.getLength());
            System.out.println("Message received: " + message);
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            // 关闭DatagramSocket对象
            if (socket != null && !socket.isClosed()) {
                socket.close();
            }
        }
    }
}

示例中，发送端将字符串"Hello, UDP!"发送到接收端的端口号9876上。接收端接收到数据后，将其转换为字符串并打印出来。

在多线程中使用UDP网络编程

发送端代码

发送端代码与之前的单线程UDP发送端代码类似，但你可以创建多个线程来发送数据报。以下是一个简单的示例，其中创建了一个线程来发送UDP数据报：

import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetAddress;

public class MultiThreadedUDPSender implements Runnable {
    private String message;
    private int port;
    private String host;

    public MultiThreadedUDPSender(String message, int port, String host) {
        this.message = message;
        this.port = port;
        this.host = host;
    }

    @Override
    public void run() {
        DatagramSocket socket = null;
        try {
            socket = new DatagramSocket();
            InetAddress address = InetAddress.getByName(host);
            byte[] buffer = message.getBytes();
            DatagramPacket packet = new DatagramPacket(buffer, buffer.length, address, port);
            socket.send(packet);
            System.out.println("Message sent from thread: " + Thread.currentThread().getName() + " - " + message);
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            if (socket != null && !socket.isClosed()) {
                socket.close();
            }
        }
    }

    public static void main(String[] args) {
        // 创建多个线程来发送UDP数据报
        Thread thread1 = new Thread(new MultiThreadedUDPSender("Hello from thread 1", 9876, "localhost"));
        Thread thread2 = new Thread(new MultiThreadedUDPSender("Hello from thread 2", 9876, "localhost"));

        // 启动线程
        thread1.start();
        thread2.start();
    }
}
接收端代码

接收端代码需要使用一个线程来监听UDP端口并接收数据报。当接收到数据报时，可以在该线程中直接处理数据报，或者将其传递给其他线程进行处理。以下是一个简单的示例，其中创建了一个线程来接收和处理UDP数据报：

import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class MultiThreadedUDPReceiver implements Runnable {
    private int port;
    private ExecutorService executorService;

    public MultiThreadedUDPReceiver(int port, int numberOfThreads) {
        this.port = port;
        this.executorService = Executors.newFixedThreadPool(numberOfThreads);
    }

    @Override
    public void run() {
        DatagramSocket socket = null;
        try {
            socket = new DatagramSocket(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());
                System.out.println("Message received: " + message);

                // 将接收到的数据报传递给其他线程进行处理（可选）
                // executorService.submit(() -> processMessage(message));
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            if (socket != null && !socket.isClosed()) {
                socket.close();
            }
            if (!executorService.isShutdown()) {
                executorService.shutdown();
            }
        }
    }

    // 示例处理函数（可选）
    private void processMessage(String message) {
        // 处理接收到的消息
        System.out.println("Processing message: " + message);
    }

    public static void main(String[] args) {
        // 创建线程来接收UDP数据报
        int port = 9876;
        int numberOfThreads = 4; // 线程池中的线程数量（可根据需要调整）
        Thread receiverThread = new Thread(new MultiThreadedUDPReceiver(port, numberOfThreads));

        // 启动线程
        receiverThread.start();
    }
}
注意事项
  1. ‌线程安全‌：在多线程环境中，需要确保对共享资源的访问是线程安全的。例如，如果多个线程需要访问同一个DatagramSocket对象，则需要使用同步机制来避免竞争条件。
  2. ‌性能‌：创建和管理线程会消耗系统资源，因此需要根据实际需求来合理设置线程的数量。如果线程数量过多，可能会导致系统性能下降。
  3. ‌异常处理‌：在多线程环境中，需要特别注意异常处理。如果某个线程出现异常并终止，可能会导致整个程序崩溃或不稳定。因此，需要在每个线程中添加适当的异常处理逻辑。

http://www.kler.cn/a/459303.html

相关文章：

  • AWS 申请证书、配置load balancer、配置域名
  • 人工智能之机器学习算法
  • 简易Type-C拉取5V/3A电流电路分享
  • Flutter Android修改应用名称、应用图片、应用启动画面
  • mysql连接时报错1130-Host ‘hostname‘ is not allowed to connect to this MySQL server
  • 2025加密风云：行业变革与未来趋势全景透视
  • qingzhou
  • 【Ubuntu】Ubuntu server 18.04 搭建Slurm并行计算环境（包含NFS）
  • WinForm事件遇到异步方法的处理方式
  • 5_SparkGraphX讲解
  • 职场中哪些话中话，弦外之音
  • word中插入zotero引用
  • QT写的动态正弦曲线图显示并打印
  • 多模态机器人
  • 24.小R的随机播放顺序＜字节青训营-中等题＞
  • 实战指南：Shiro、CAS打造完美单点登录体验
  • 运行python程序报错 undefined symbol: ffi_type_uint32 的参考解决方法
  • 马原复习笔记
  • AWS K8s 部署架构
  • 在云服务器中编译IDF（ESP32库）
  • 2024年个人总结
  • 使用 PyInstaller 和 hdiutil 打包 Tkinter 应用为 macOS 可安装的 DMG 文件
  • 统计颜色Count Color（POJ2777）题解
  • 【UE5 C++课程系列笔记】16——DeveloperSettings（开发者设置）的基本使用——创建配置文件
  • 【linux进程】进程终止进程等待
  • CSS（层叠样式表）基础选择器，文字控制属性