Question

我有一个小问题，我有一个TCP类连接到服务器，传输数据然后关闭，这一切都很好，除非我连接，然后停止它，它工作，如果我继续这样做，它工作，但第五次连接挂起没有任何错误，并没有传输任何数据..我不知道如何解决这个...这是我的TCP类代码：

package com.millennium.isynccrm.Classes;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.net.Socket;
import java.net.UnknownHostException;

import android.os.AsyncTask;
import android.os.CountDownTimer;
import android.util.Log;

public class TcpClient {

public static boolean connected = false;
private static Socket socket;
private static boolean pause = false;
private static SyncClient syncClient = new SyncClient();
public static int sendCount = 0;
public static int receiveCount = 0;
private static AsyncTask<?, ?, ?> sendAsyncTask;
private static AsyncTask<?, ?, ?> receiveAsyncTask;

public TcpClient() { }

public void send (String line) {
    if (!connected) connect();
    while (!connected) { }
    sendAsyncTask = new SenderThread().execute(line);
}

public void disconnect() {
    try {
        if(connected == true) {
            socket.close();
            connected = false;
            sendCount = 0;
            receiveCount = 0;
            if (receiveAsyncTask.getStatus().name().equals("RUNNING")) {
                receiveAsyncTask.cancel(true);
            }
            if (sendAsyncTask.getStatus().name().equals("RUNNING")) {
                sendAsyncTask.cancel(true); 
            }
        }
    } catch (IOException e) {
        e.printStackTrace();
    }
}

public void pauseReceivingForTimeInterval(int milliseconds) {
    pause = true;
    new CountDownTimer(milliseconds, 0) {

         public void onTick(long millisUntilFinished) { }

         public void onFinish() {
             pause = false;
         }
      }.start();

}

private void connect() {
     new Thread(new Runnable() {
         public void run() {
                try {
                    if (connected == false) {
                        socket = new Socket("192.168.1.1", 80);
                        connected = true;
                        sendCount = 0;
                        receiveCount = 0;
                        try {
                            if (receiveAsyncTask.getStatus().name().equals("FINISHED")) {
                                receiveAsyncTask = new RecieverThread().execute("");
                            } else if (receiveAsyncTask.getStatus().name().equals("RUNNING")) {
                                receiveAsyncTask.cancel(true);
                                receiveAsyncTask = new RecieverThread().execute("");
                            }
                        } catch (Exception e) { receiveAsyncTask = new RecieverThread().execute(""); }
                    }
                } catch (UnknownHostException e) {
                        connected = false;
                        e.printStackTrace();
                } catch (IOException e) {
                        connected = false;
                        e.printStackTrace();
                }
            }
     }).start();
}

private static PrintWriter output;
private static BufferedReader input = null;

private class RecieverThread extends AsyncTask<String, Void, String> {
     protected String doInBackground(String... line) {
         while (pause) { }
         try {
             receiveCount++;
             if (receiveCount == 1) input = new BufferedReader(new InputStreamReader(socket.getInputStream()), 8 * 1024);
             return input.readLine();

         } catch (IOException e) {
             Log.d("error", "stop");
         }
         return "stop";
     }

     protected void onPostExecute(String result) {
         if (result == null) return;
         else if (!result.equals("") && !result.equals("stop")) syncClient.recieveMessage(result);
         else if (!result.equals("stop")) receiveAsyncTask = new RecieverThread().execute("");
     }
}

private class SenderThread extends AsyncTask<String, Void, String> {
     protected String doInBackground(String... line) {
         while (pause) { }
         sendCount++;
         if (sendCount == 1) {
             try {
                 output = new PrintWriter(socket.getOutputStream(),true);
             } catch(Exception e) { e.printStackTrace(); }
         }

         String msg = line[0] + "\r\n";
         output.print(msg);
         output.flush();
         return "";
     }

     protected void onPostExecute(String result) {

     }
 }

}

正如您所看到的，另一个类向此类发送一行以发送到服务器，然后Async任务发送它，另一个异步任务接收它并将其传递到另一个处理它的类，依此类推。在UI上我有一个开始按钮，当按下该按钮变成停止按钮时，当按下停止时，它会调用此处的“断开”功能。

我不太确定无论我在哪里完成我的RecieverThread AsyncTask是正确的，它等待来自套接字的一行然后将其传递并重新启动它以监听另一条线，这是一种'好'的做法这个？或者这是一种可怕的方式（我想象的是）。说实话，我认为这堂课非常“混乱”，我很可能会重做它。

有关为什么我第五次连接服务器时永远无法发送数据的建议？（最后一点，服务器在这里不应该受到指责，因为我们有一个iPhone应用程序可以做同样的事情）（额外的注意事项..我对Tcp连接和那种东西都是新手，并且是新的线程/异步任务。）：）

任何帮助，协助都将非常感谢（：谢谢！

Answer 1

while（！connected）{} ???那是不可能做任何异步的事情。您正在占用CPU等待发生的事情，并通过占用CPU来阻止它发生。使用选择器，或进行阻塞模式连接。

异步Tcp连接

1 个答案: