Android 如何在关闭活动时停止活动线程和套接字

你好。我有一个Android应用程序连接到一个使用TCP连接的C++服务器。 我的第一个活动允许用户写入ip地址和端口以连接到服务器，然后此活动使用intent调用另一个活动。 第二个活动执行套接字连接并运行两个线程

第二个活动还有一个断开按钮；当您按下该按钮时，它应该停止所有正在运行的线程，关闭套接字连接并返回到活动一，并让用户在需要时再次连接。我还无法这样做。 我已尝试使用

socket.close（）

，但随后我的线程崩溃，不允许重新连接。我还尝试了

this.onDestroy（）

或

this.finish（）

；活动已关闭，但仍连接到服务器

如何在完成活动时完成所有线程和套接字并返回到上一个活动

为了更清楚，我的代码如下：

第一项活动：

public class FirstActivity extends Activity {
 EditText editTextAddress, editTextPort; 
 Button buttonConnect, buttonClear;
 Intent intent;
 @Override
 protected void onCreate(Bundle savedInstanceState) {
      super.onCreate(savedInstanceState);
      setContentView(R.layout.activity_ipclient);

      editTextAddress = (EditText)findViewById(R.id.address);
      editTextPort = (EditText)findViewById(R.id.port);
      buttonConnect = (Button)findViewById(R.id.connect);  
 }
 public void onClickConnect(View v){
     String ip=editTextAddress.getText().toString();
     int port=Integer.valueOf(editTextPort.getText().toString());
     intent=new Intent(this,SecondActivity.class);
     Bundle extrasB=new Bundle();
     extrasB.putString("ip",ip);
     extrasB.putInt("port",port);
     intent.putExtras(extrasB);
     startActivity(intent);
 }
}

第二活动

public class SecondActivity extends Activity {
....

@Override
public void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.activity_client_late);
    .....
    updateConversationHandler = new Handler();
    new Thread(new ClientThread()).start();
    sendImage=new SendImage();
    sendImage.execute();
 }
    public class SendImage extends AsyncTask<Void,Void,Void>{
    @Override
    protected Void doInBackground(Void... arg0){
        .....
    }
}
class ClientThread implements Runnable {

    @Override
    public void run() {

        thread1=Thread.currentThread();
        try {
            InetAddress serverAddr = InetAddress.getByName(SERVER_IP);
            socket = new Socket(serverAddr, SERVERPORT);

            socketTE = new Socket(serverAddr, SERVERPORT);
            CommunicationThread commThread = new CommunicationThread(socketTE);
            new Thread(commThread).start();
        } catch (UnknownHostException e1) {
            e1.printStackTrace();
        } catch (IOException e1) {
            e1.printStackTrace();
        }
    }

}

class CommunicationThread implements Runnable 
{

    private Socket clientSocket;
    private BufferedReader input;
    public CommunicationThread(Socket clientSocket) 
    {
        thread2=Thread.currentThread();
        this.clientSocket = clientSocket;
        ....

    }
    public void run() 
    {
        while (!Thread.currentThread().isInterrupted()) 
        {
            .....                   
        }
    }
}

class updateUIThread implements Runnable 
{
    private String msg;
    public updateUIThread(String str) 
    {
        thread3=Thread.currentThread();
        ...
    }
    @Override
    public void run() 
    {                     
            ....
    }
}

**public void disconnectButtonOnCLick(View v) throws IOException{
    super.onStop();
    super.finish();
}**
@Override
protected void onDestroy() {
    super.onDestroy();
    sendImage.cancel(true);
    thread1.interrupt();        
    thread2.interrupt();
    thread3.interrupt();
    try {
        socket.close();
        socketTE.close();
    } catch (IOException e) {
        // TODO Auto-generated catch block
        e.printStackTrace();
    }
}

}

公共类SecondActivity扩展活动{
....
@凌驾
创建时的公共void（Bundle savedInstanceState）{
super.onCreate（savedInstanceState）；
setContentView（R.layout.activity\u client\u late）；
.....
updateConversationHandler=新处理程序（）；
新线程（新ClientThread（））.start（）；
sendImage=新建sendImage（）；
sendImage.execute（）；
}
公共类SendImage扩展异步任务{
@凌驾
受保护的Void doInBackground（Void…arg0）{
.....
}
}
类ClientThread实现Runnable{
@凌驾
公开募捐{
thread1=Thread.currentThread（）；
试一试{
inetAddressServerAddr=InetAddress.getByName（服务器IP）；
套接字=新套接字（serverAddr、SERVERPORT）；
socketTE=新套接字（serverAddr、SERVERPORT）；
CommunicationThread commThread=新的CommunicationThread（socketTE）；
新线程（commThread.start（）；
}捕获（未知后异常e1）{
e1.printStackTrace（）；
}捕获（IOE1异常）{
e1.printStackTrace（）；
}
}
}
类通信读取实现可运行
{
私有套接字clientSocket；
专用缓冲读取器输入；
公共通信读取（套接字客户端套接字）
{
thread2=Thread.currentThread（）；
this.clientSocket=clientSocket；
....
}
公开募捐
{
而（！Thread.currentThread（）.isInterrupted（））
{
.....                   
}
}
}
类updateUIThread实现可运行
{
私有字符串msg；
公共updateUIThread（字符串str）
{
thread3=Thread.currentThread（）；
...
}
@凌驾
公开募捐
{                     
....
}
}
**公共void disconnectButtonNonclick（视图v）引发IOException{
super.onStop（）；
super.finish（）；
}**
@凌驾
受保护的空onDestroy（）{
super.ondestory（）；
sendImage.cancel（true）；
thread1.中断（）；
thread2.中断（）；
thread3.中断（）；
试一试{
socket.close（）；
socketTE.close（）；
}捕获（IOE异常）{
//TODO自动生成的捕捉块
e、 printStackTrace（）；
}
}
}

对于异步任务：

@Override
    public void onPause(){
        super.onPause();
        if (sendImage!=null) {
            sendImage.cancel(true);
            }
}

---

首先，你不应该显式地调用这个.onDestroy（）。您应该调用finish（）来关闭活动。onDestroy（）是一个回调，在Acvity正在销毁时调用。因此，您应该像使用onCreate（）一样重写onDestroy：

第二。要关闭所有线程，您可以查看此线程-。您还可以使用布尔变量指示线程是否已停止：

publicstaticboolean类似于上面链接中的Malcolm的回答。
以及如何关闭插座-。
希望这有帮助。
我应该在哪里调用onPause方法？不应该显式调用onPause。它是自动调用的。请看一看:
@Override
protected void onDestroy() {
    super.onDestroy();
    // close all your threads
}