Java 使用asynctask从套接字返回对象

我正在尝试保存通过套接字连接获得的集合。我使用

AsyncTask

从包含集合的套接字读取消息。我的问题是我无法保存此邮件。在

OnpostExecute（）

中，不会显示Log.d（）消息。如果我执行

ReceiveMsgAsyncTask（）.execute（）.get（）

UI将冻结。我读过许多类似的问题，但我找不到解决办法。如何保存从我的套接字收到的消息？提前感谢

private class ReceiveMsgAsyncTask extends AsyncTask<Object, Void, Object> {
    final Collection <String> col = new ArrayList<String>();
    Socket socket = null ;
    ObjectInputStream in = null;
    @Override
    protected Object doInBackground(Object... arg0) {
        // TODO Auto-generated method stub;
        Object msg = null;
         try {
                socket = new Socket(host,50000);
                in = new ObjectInputStream(socket.getInputStream());
                msg = in.readObject();
            } catch (UnknownHostException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            } catch (IOException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            } catch (ClassNotFoundException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }finally {
                try {
                    in.close();
                    socket.close();
                } catch (IOException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
            }
        return msg;
    }

    protected void onPostExecute(Object result) {
        // TODO Auto-generated method stub
        Log.d("mesg","success");
        super.onPostExecute(result);
        col.addAll((Collection<?extends String>)result);
    }

私有类ReceiveMsgAsyncTask扩展异步任务{
最终集合col=new ArrayList（）；
套接字=空；
ObjectInputStream in=null；
@凌驾
受保护对象doInBackground（对象…arg0）{
//TODO自动生成方法存根；
对象msg=null；
试一试{
插座=新插座（主机，50000）；
in=newObjectInputStream（socket.getInputStream（））；
msg=in.readObject（）；
}捕获（未知后异常e）{
//TODO自动生成的捕捉块
e、 printStackTrace（）；
}捕获（IOE异常）{
//TODO自动生成的捕捉块
e、 printStackTrace（）；
}catch（classnotfounde异常）{
//TODO自动生成的捕捉块
e、 printStackTrace（）；
}最后{
试一试{
in.close（）；
socket.close（）；
}捕获（IOE异常）{
//TODO自动生成的捕捉块
e、 printStackTrace（）；
}
}
返回味精；
}
受保护的void onPostExecute（对象结果）{
//TODO自动生成的方法存根
日志d（“mesg”，“成功”）；
super.onPostExecute（结果）；
col.addAll（（Collection我猜您的工人类没有实现Serializable

看

只有支持java.io.Serializable接口的对象才能写入流

请看这份文件，它清楚地说明了这一点


如有必要，等待计算完成，然后检索其结果。

因此，调用“get”否定了使用asynctask的全部理由

您需要做的是：

使用回调方法创建接口
使您的活动或片段实现该接口
让你的ReceiveMsgAsyncTask接受一个在其构造函数上实现该接口的对象
在ReceiveMsgAsyncTask的onPostExecute中，调用将结果传递给它的回调方法
现在常见的陷阱是，如果活动被关闭或以其他方式呈现为失效，会发生什么。这可能会导致崩溃和其他各种奇怪的情况

解决此问题的最简单方法是保留任何未完成异步任务的副本，然后在活动或片段暂停方法中取消。
那么是否有服务器在主机上发送内容：50000？如果尝试telnet，您可以连接吗？否，连接可以工作…问题是我无法保存从连接读取的对象n、 （msg=in.readObject（））如果服务器通过原始tcp套接字向您发送该对象，那么您的代码应该可以工作。另一方面，您应该在一段时间后在logcat中看到某种异常。如果您看到，请将其添加到您的问题中。请发布您的服务器代码。虽然它不工作…col为空…不，我使用AsyncTask时没有异常。execute（）。当我使用AsyncTask.execute（）.get（1，TimeUnit.millizes）时，我有一个java.util.concurrent.TimeoutException；事实上，我的工人类没有实现Serializable。我修复了它，但问题仍然存在……col是空的。在服务器端col不是空的。那么
Mworker.getCollection（）呢
-您的集合可序列化吗？您的意思是这样的吗？private Collection1。我创建了一个带有回调（）方法的接口2.我的活动是为了实现该接口3.我不明白…AsyncTasks没有构造函数方法。很抱歉，我对这种东西不熟悉。你能给我一个例子吗？谢谢
public interface ReceiveInterface{void callback（）；}
try
public interface ReceiveInterface{void callback（对象结果）；}
毕竟我的问题出在服务器上。谢谢大家的回答
public void splitData(Master master,String client){
        int chunk=0;
        int chunckStart=0;
            BufferedReader br = null;
            ObjectOutputStream out = null;
            try {
                String sCurrentLine;
                br = new BufferedReader(new FileReader("input"));
                int numberOflines=0;
                while ((sCurrentLine = br.readLine()) != null) {
                    numberOflines++;
                }
                br.close();
                br = new BufferedReader(new FileReader("input"));
                for (int i=1;i<=master.numberOfWorkers;i++){
                    out = new ObjectOutputStream(incoming.getOutputStream());
                    Worker Mworker = new Worker(clientsList.get(i-1));
                    if (i==master.numberOfWorkers){
                        if (numberOflines%master.numberOfWorkers!=0)
                            chunk = ((numberOflines/master.numberOfWorkers)*i)+numberOflines%master.numberOfWorkers;
                        else chunk = ((numberOflines/master.numberOfWorkers)*i);
                    }
                    else chunk = ((numberOflines/master.numberOfWorkers)*i);
                    int counter = chunk;
                    while (counter>chunckStart) {
                        sCurrentLine = br.readLine();
                        System.out.println(sCurrentLine);
                        //Mworker.reduce(sCurrentLine, 1);
                        Mworker.getCollection().add(sCurrentLine);
                        counter--;
                    }
                    System.out.println("----------------------------------");
                    chunckStart = chunckStart +(numberOflines/master.numberOfWorkers);
                    System.out.println(Mworker.getWorkerName()+" has the list:");
                    //System.out.println(Mworker.getHashReduce());
                    System.out.println(Mworker.getCollection());
                    out.writeObject(Mworker.getCollection());//send chunk to the worker/client
                    //out.flush();
                    //out.close();
                }

            } catch (IOException e) {
                e.printStackTrace();
            } finally {
                try {
                    if (br != null) br.close();
                } catch (IOException ex) {
                    ex.printStackTrace();
                }
            }
            //Mworker.hashReduce
        //}
    }