Java 异步任务中的getInputStream

我有一个活动，它调用异步任务，通过预定义的InetAddress接受套接字连接

异步任务调用另一个异步任务来侦听中的消息。但它挂起在get输入流上

我已经绞尽脑汁几个小时了，弄不明白它为什么要挂起来……请帮忙

public void startSocketListener(InetAddress groupOwnerAddress) {
    // TODO Auto-generated method stub
    AcceptClientThread accept;
    try {
        accept = new AcceptClientThread();
        accept.execute();
    } catch (IOException e) {
        // TODO Auto-generated catch block
        e.printStackTrace();
    }


}

public class AcceptClientThread extends AsyncTask<Void, String, String>{

    public AcceptClientThread() throws IOException{

    }

    @Override
    protected void onCancelled() {
        // TODO Auto-generated method stub
        try {
            serverSocket.close();
        } catch (IOException e) {
            // TODO Auto-generated catch block
            Log.e("CONNECTION ERR", "Could not close serverSocket " + e.toString());
        }
        super.onCancelled();
    }

    @Override
    protected String doInBackground(Void... params) {

        try {
            serverSocket = new ServerSocket(port);
        } catch (IOException e) {
            Log.e("CONNECTION ERR","Could not listen on port: " + port);
            onCancelled();
        }

        while (listening){
            try {
                Log.i("CONNECTION", "AWAITING CONNECTION TO CLIENT");
                Socket newSocket = serverSocket.accept();
                Log.i("CONNECTION", "CONNECTED TO CLIENT");
                ListenerThread lThread = new ListenerThread(newSocket);
                lThread.execute("Do it");
                Log.i("CONNECTION", "ACCEPTED CLIENT");
            } catch (IOException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
                onProgressUpdate("could not accept client");
            }

        }
        Log.i("CONNECTION", "close socket");
        try {
            serverSocket.close();
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }

        return "table connected";
    }

    @Override
    protected void onProgressUpdate(String... values) {
        super.onProgressUpdate(values);
        // received data is first element in the String
        //Toast.makeText(KitchenActivity.this, values[0], Toast.LENGTH_SHORT).show();
    }

}

public class ListenerThread extends AsyncTask<String, Order, Void> {

    private Socket socket;
    ObjectInputStream ois;

    public ListenerThread(Socket socket){
        this.socket = socket;
        try {
            ois = new ObjectInputStream(this.socket.getInputStream()); //hangs here
        } catch (StreamCorruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }

public void startSocketListener（InetAddress组所有者地址）{
//TODO自动生成的方法存根
AcceptClientThreadAccept；
试一试{
accept=新的AcceptClientThread（）；
accept.execute（）；
}捕获（IOE异常）{
//TODO自动生成的捕捉块
e、 printStackTrace（）；
}
}
公共类AcceptClientThread扩展异步任务{
public AcceptClientThread（）引发IOException{
}
@凌驾
受保护的void onCancelled（）{
//TODO自动生成的方法存根
试一试{
serverSocket.close（）；
}捕获（IOE异常）{
//TODO自动生成的捕捉块
Log.e（“连接错误”，“无法关闭serverSocket”+e.toString（））；
}
super.onCancelled（）；
}
@凌驾
受保护字符串doInBackground（无效…参数）{
试一试{
serverSocket=新的serverSocket（端口）；
}捕获（IOE异常）{
Log.e（“连接错误”，“无法侦听端口：“+端口”）；
onCancelled（）；
}
边听{
试一试{
Log.i（“连接”，“等待连接到客户端”）；
Socket newSocket=serverSocket.accept（）；
Log.i（“连接”，“连接到客户端”）；
ListenerThread lThread=新ListenerThread（newSocket）；
lThread.execute（“doit”）；
Log.i（“连接”、“接受的客户”）；
}捕获（IOE异常）{
//TODO自动生成的捕捉块
e、 printStackTrace（）；
onProgressUpdate（“无法接受客户端”）；
}
}
Log.i（“连接”、“关闭插座”）；
试一试{
serverSocket.close（）；
}捕获（IOE异常）{
//TODO自动生成的捕捉块
e、 printStackTrace（）；
}
返回“表已连接”；
}
@凌驾
受保护的void onProgressUpdate（字符串…值）{
super.onProgressUpdate（值）；
//接收到的数据是字符串中的第一个元素
//Toast.makeText（KitchenActivity.this，值[0]，Toast.LENGTH_SHORT.show（）；
}
}
公共类ListenerThread扩展异步任务{
专用插座；
目的输入流ois；
公共ListenerThread（套接字）{
this.socket=socket；
试一试{
ois=newObjectInputStream（this.socket.getInputStream（））；//挂起
}捕获（StreamCorruptedException e）{
//TODO自动生成的捕捉块
e、 printStackTrace（）；
}捕获（IOE异常）{
//TODO自动生成的捕捉块
e、 printStackTrace（）；
}
}

我不确定，但我想您只能从UI线程调用AsyncTask.execute（），您正在尝试从doInBackground（）执行，它在单独的线程中运行。

根据

线程规则

必须遵循一些线程规则 要使该类正常工作，请执行以下操作：

必须在UI线程上加载AsyncTask类。此操作已完成 从JELLY_BEAN开始自动执行。必须在上创建任务实例 用户界面线程

您可以在

accept（）

成功后，在第一个

AsyncTask的
onPostExecute（）
中调用新的
线程来处理此问题，因为
onPostExecute（）
在
UI
上运行

另外，不必再多看，我相信在它接受请求后，你会希望在第一个任务中打破你的
while循环
。然后当你需要建立另一个连接时，你会在你的
UI
中创建这个任务的一个新实例，并再次执行它。我对最后一部分不满意从长远来看，这似乎是正确的
理想情况下，我希望能够拥有尽可能多的连接，我会将其放入一个数组中，然后尝试itAsyncTask，它是为后台工作而设计的。像服务器那样处理请求需要您实现一些更合适的功能，例如准备好处理这些请求的工作线程池。您可以想看看ThreadPoolExecutor类。
正在侦听
是否曾经
为false
？现在看起来您有一个
无限循环
，它一直在尝试创建一个新的
套接字
，除非我遗漏了什么。当用户关闭活动或按下按钮时，侦听等于false。这只是侦听传入连接