在哪里停止/销毁安卓服务类中的线程？

service android multithreading java

2022-09-01 04:11:27

我通过以下方式创建了一个线程服务：

public class TCPClientService extends Service{  
...

@Override
public void onCreate() {
    ...
    Measurements = new LinkedList<String>();
    enableDataSending();    
}

@Override
public IBinder onBind(Intent intent) {
    //TODO: Replace with service binding implementation
    return null;
}

@Override
public void onLowMemory() {
    Measurements.clear();
    super.onLowMemory();
}

@Override
public void onDestroy() {
    Measurements.clear();
    super.onDestroy();
    try {
        SendDataThread.stop();
    } catch(Exception e){
        ...     
    }

}

private Runnable backgrounSendData = new Runnable() {

    public void run() {
        doSendData();
    }
};

private void enableDataSending() {
    SendDataThread = new Thread(null, backgrounSendData, "send_data");
    SendDataThread.start();
}

 private void addMeasurementToQueue() {
     if(Measurements.size() <= 100) {
         String measurement = packData();
         Measurements.add(measurement);
     }
 }

 private void doSendData() {
     while(true) {
         try {      
             if(Measurements.isEmpty()) {
                 Thread.sleep(1000);
                 continue;
             }
             //Log.d("TCP", "C: Connecting...");
             Socket socket = new Socket();
             socket.setTcpNoDelay(true);
             socket.connect(new InetSocketAddress(serverAddress, portNumber), 3000);
             //socket.connect(new InetSocketAddress(serverAddress, portNumber));
             if(!socket.isConnected()) {
                 throw new Exception("Server Unavailable!");
             }
             try {
                 //Log.d("TCP", "C: Sending: '" + message + "'");
                 PrintWriter out = new PrintWriter( new BufferedWriter( new OutputStreamWriter(socket.getOutputStream())),true);
                 String message = Measurements.remove();
                 out.println(message);
                 Thread.sleep(200);
                 Log.d("TCP", "C: Sent.");
                 Log.d("TCP", "C: Done.");
                 connectionAvailable = true;              
             } catch(Exception e) {
                 Log.e("TCP", "S: Error", e);
                 connectionAvailable = false;
             } finally {
                 socket.close();
                 announceNetworkAvailability(connectionAvailable);
             }
         } catch (Exception e) {
             Log.e("TCP", "C: Error", e);
             connectionAvailable = false;
             announceNetworkAvailability(connectionAvailable);
         }
    }
}

...
}

关闭应用程序后，手机工作非常慢，我猜这是由于线程终止失败。

有谁知道在终止应用程序之前终止所有线程的最佳方法是什么？

答案 1

附录：Android框架为一次性工作，后台工作等提供了许多帮助程序，在许多情况下，这可能比尝试滚动自己的线程更可取。正如下面的一篇文章中提到的，AsyncTask是一个很好的起点。我鼓励读者在开始考虑自己做线程之前先研究框架条款。

您发布的代码示例中有几个问题，我将按顺序解决：

1） Thread.stop（）已经弃用了很长一段时间，因为它在某些情况下会使因变量处于不一致的状态。有关更多详细信息，请参阅此 Sun 答案页面（编辑：该链接现已失效，请参阅此页面，了解为什么不使用 Thread.stop（））。停止和启动线程的首选方法如下（假设您的线程将无限期地运行）：

private volatile Thread runner;

public synchronized void startThread(){
  if(runner == null){
    runner = new Thread(this);
    runner.start();
  }
}

public synchronized void stopThread(){
  if(runner != null){
    Thread moribund = runner;
    runner = null;
    moribund.interrupt();
  }
}

public void run(){
  while(Thread.currentThread() == runner){
    //do stuff which can be interrupted if necessary
  }
}

这只是如何停止线程的一个示例，但要点是，您负责退出线程，就像退出任何其他方法一样。维护一个跨线程通信方法（在本例中为易失性变量，也可以通过互斥体等），并在线程逻辑中使用该通信方法来检查是否应该提前退出、清理等。

2）多个线程（事件线程和用户线程）同时访问测量列表，无需任何同步。看起来您不必滚动自己的同步，可以使用BlockningQueue。

3）您正在创建一个新的套接字，每次迭代您的发送线程。这是一个相当重量级的操作，只有当您期望测量非常不频繁（例如每小时一次或更短）时，才真正有意义。要么你想要一个持久的套接字，而不是在线程的每个循环中重新创建，要么你想要一个可以“触发并忘记”的一次性运行，它创建一个套接字，发送所有相关数据，然后完成。（关于使用持久套接字的快速说明，套接字方法，如读取，不能被Thread.interrupt（）中断，所以当你想要停止线程时，你必须关闭套接字以及调用中断）

4）从线程中抛出自己的异常没有多大意义，除非你期望在其他地方捕获它。更好的解决方案是记录错误，如果无法恢复，请停止线程。线程可以使用如下代码停止自身（在与上面相同的上下文中）：

public void run(){
    while(Thread.currentThread() == runner){
      //do stuff which can be interrupted if necessary

      if(/*fatal error*/){
        stopThread();
        return; //optional in this case since the loop will exit anyways
      }
    }
  }

最后，如果你想确保一个线程与应用程序的其余部分一起退出，无论如何，一个好的技术是在创建后和启动线程之前调用Thread.setDaemon（true）。这会将线程标记为守护程序线程，这意味着如果没有正在运行的非守护程序线程（例如，如果应用退出），VM 将确保自动销毁该线程。

遵守有关线程的最佳实践应确保您的应用程序不会挂起或减慢手机速度，尽管它们可能非常复杂:)

答案 2

实际上，您不需要如上所述的“runner”变量，例如：

while (!interrupted()) {
    try {
        Thread.sleep(1000);
    } catch (InterruptedException ex) {
        break;
    }
}

但一般来说，坐在Thread.sleep（）循环中是一个非常糟糕的主意。

查看新的 1.5 API 中的 AsyncTask API。它可能会比使用服务更优雅地解决您的问题。您的手机速度变慢，因为服务永远不会关闭 - 没有什么会导致服务自行终止。