首先，你的核心需求是在后台持续发送UDP数据报（按钮状态、摇杆值等），之前遇到的问题主要出在：

• 直接用无限循环如果在主线程会阻塞UI导致崩溃；如果在AsyncTask里跑长期循环，AsyncTask的线程池设计不适合这类长期运行任务，而且它已经被官方废弃了。
• 你的现有代码只是单次发送UDP包，没有实现持续发送的逻辑，还存在StaticFieldLeak的风险（内部AsyncTask类持有外部UDP_Client的引用）。

下面给你两种可行的方案，分别适配Java和Kotlin，都是Android当前推荐的做法：

方案一：Java 用 ExecutorService 实现后台持续发送 #

我们可以用ExecutorService创建一个专用的后台线程来运行持续发送的任务，同时做好生命周期管理（比如在页面销毁时停止任务，避免内存泄漏）。

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

public class UDPClient {
    private final String serverIp;
    private final int serverPort;
    private ExecutorService executorService;
    private Future<?> sendTask;
    // 用来保存要发送的最新数据（比如按钮状态、摇杆值）
    private volatile String latestMessage;

    public UDPClient(String serverIp, int serverPort) {
        this.serverIp = serverIp;
        this.serverPort = serverPort;
        // 创建单线程线程池
        executorService = Executors.newSingleThreadExecutor();
    }

    // 更新要发送的最新数据
    public void updateMessage(String message) {
        this.latestMessage = message;
    }

    // 开始持续发送
    public void startSending() {
        if (sendTask != null && !sendTask.isCancelled()) {
            return; // 已经在发送了，避免重复启动
        }
        sendTask = executorService.submit(() -> {
            try (DatagramSocket socket = new DatagramSocket()) {
                socket.setBroadcast(true);
                InetAddress address = InetAddress.getByName(serverIp);
                // 持续发送直到任务被取消
                while (!Thread.currentThread().isInterrupted()) {
                    if (latestMessage == null || latestMessage.isEmpty()) {
                        Thread.sleep(100); // 没有数据时短暂休眠，避免空转
                        continue;
                    }
                    byte[] data = latestMessage.getBytes();
                    DatagramPacket packet = new DatagramPacket(data, data.length, address, serverPort);
                    socket.send(packet);
                    // 控制发送频率，比如每100ms发一次，根据你的需求调整
                    Thread.sleep(100);
                }
            } catch (InterruptedException e) {
                // 任务被中断，正常退出
                Thread.currentThread().interrupt();
            } catch (Exception e) {
                e.printStackTrace();
                // 发送失败时可以加重试逻辑，或者短暂休眠后继续
                try {
                    Thread.sleep(500);
                } catch (InterruptedException ie) {
                    Thread.currentThread().interrupt();
                }
            }
        });
    }

    // 停止发送，释放资源
    public void stopSending() {
        if (sendTask != null) {
            sendTask.cancel(true);
            sendTask = null;
        }
        if (executorService != null && !executorService.isShutdown()) {
            executorService.shutdownNow();
            executorService = null;
        }
    }
}

使用说明： #

1. 在你的Activity/Fragment里初始化UDPClient：

   private UDPClient udpClient;
   
   @Override
   protected void onCreate(Bundle savedInstanceState) {
       super.onCreate(savedInstanceState);
       udpClient = new UDPClient("192.168.xxx.xxx", 3000);
   }
   

2. 当按钮/摇杆状态变化时，调用udpClient.updateMessage("你的JSON字符串或数据")
3. 在页面启动时（比如onResume）调用udpClient.startSending()
4. 在页面销毁时（比如onDestroy）调用udpClient.stopSending()，避免内存泄漏

方案二：Kotlin 用协程（Coroutines）实现（推荐） #

Kotlin协程是Android官方推荐的异步编程方案，比线程更轻量，且更容易管理生命周期，避免内存泄漏。

import kotlinx.coroutines.*
import java.net.DatagramPacket
import java.net.DatagramSocket
import java.net.InetAddress

class UDPClient(
    private val serverIp: String,
    private val serverPort: Int,
    private val coroutineScope: CoroutineScope // 用lifecycleScope或viewModelScope来管理生命周期
) {
    private var sendJob: Job? = null
    @Volatile
    private var latestMessage: String? = null

    fun updateMessage(message: String) {
        latestMessage = message
    }

    fun startSending() {
        if (sendJob?.isActive == true) return
        sendJob = coroutineScope.launch(Dispatchers.IO) {
            runCatching {
                DatagramSocket().use { socket ->
                    socket.broadcast = true
                    val address = InetAddress.getByName(serverIp)
                    while (isActive) { // 协程活跃时持续发送
                        val msg = latestMessage ?: run {
                            delay(100)
                            return@launch
                        }
                        val data = msg.toByteArray()
                        val packet = DatagramPacket(data, data.size, address, serverPort)
                        socket.send(packet)
                        delay(100) // 控制发送频率
                    }
                }
            }.onFailure {
                it.printStackTrace()
                delay(500) // 发送失败后重试间隔
                if (isActive) startSending() // 如果协程还活跃，重新启动发送
            }
        }
    }

    fun stopSending() {
        sendJob?.cancel()
        sendJob = null
    }
}

使用说明： #

在Activity里使用：

private lateinit var udpClient: UDPClient

override fun onCreate(savedInstanceState: Bundle?) {
    super.onCreate(savedInstanceState)
    // 用lifecycleScope，页面销毁时协程会自动取消
    udpClient = UDPClient("192.168.xxx.xxx", 3000, lifecycleScope)
}

override fun onResume() {
    super.onResume()
    udpClient.startSending()
}

override fun onDestroy() {
    super.onDestroy()
    udpClient.stopSending()
}

// 比如摇杆值变化时调用
fun onJoystickChanged(x: Float, y: Float) {
    val json = """{"x":$x,"y":$y}"""
    udpClient.updateMessage(json)
}

关键注意点： #

• 发送频率控制：不要无休眠地疯狂发送，这样会占用过多CPU和网络资源，根据无人机控制的需求设置合适的间隔（比如100ms一次）。
• 生命周期管理：一定要在页面销毁或不需要发送时停止任务，否则会导致内存泄漏，甚至后台耗电。
• 异常处理：UDP发送可能会因为网络问题失败，不要让一次失败导致整个任务终止，要加入重试或休眠逻辑。
• 数据线程安全：用volatile修饰要发送的最新数据，避免多线程下的可见性问题。

内容的提问来源于stack exchange，提问作者Anmol sharma