Java ServerSocket和Android LocalServerSocket

Question

我已经实现了我自己的android服务，如下所示

public class MyService extends Service {
    private static final String TAG = "MyService";

    private Server mServer; 
    private LocalServerSocket server;

    @Override
    public IBinder onBind(Intent intent) {
        return null;
    }

    @Override
    public void onCreate() {
        Log.d(TAG, "onCreate");
        mServer = new Server();
        mServer.start();
    }

    @Override
    public void onDestroy() {
        Log.d(TAG, "onDestroy");
        if(server != null){
            try {
                server.close();
            } catch (IOException e) {
                Log.d(TAG, "exception in server close");
                e.printStackTrace();
            }
        }
    }

    @Override
     public int onStartCommand(Intent intent, int flags, int startId) {
        Log.d(TAG, "onStart");
        return START_STICKY;
    }

    class Server extends Thread {
    @Override
        public void run() {
             try {
                server = new LocalServerSocket("my.socket");
                while (true) {
                    LocalSocket receiver;
                    try{
                        receiver = server.accept();
                    }catch(SocketException e){
                        Log.d(TAG, "SocketException");
                        break;
                    }
                    catch(IOException e){
                        Log.d(TAG, "IOException");
                        break;
                    }
                    if (receiver != null) {
                        Log.d(TAG, "Got Data in receiver");
                    }
                    receiver.close();
                }
            } catch (IOException e) {
                Log.d(TAG, "one more");
                e.printStackTrace();
            }
        }
    }
}

我面临的问题是，如果我的LocalServerSocket阻塞了accept（），那么在OnDestroy（）中对server.close（）的调用将不会引发SocketException。 因此，下次启动服务时，我会收到“地址已在使用中异常”。 如果我使用java.net.Socket而不是LocalServerSocket，则会得到所需的行为。 我想知道为什么LocalServerSocket的行为不同于Java Socket。 就我而言，我该如何退出while循环。

Answer 1

我遇到了同样的问题，并以此方式“解决”了。 线程run（）方法正在检查“！isInterrupted（）”。 我添加到侦听器线程的方法“ stopSocketServer（）”将线程标记为interrupt（），然后向其自身发出连接请求以触发accept（）方法。

/**
 * Executed if thread is started.
 */
public void run() {

    try {
        // leave while loop if thread is marked for interrupt.
        while (!isInterrupted()) { 
            LocalSocket clientSocket = serverSocket.accept();

            if (!isInterrupted()) {
                threadPool.execute(new ClientProcessor(clientSocket));
            }
        } 

    } catch (IOException e) {
        if (!isInterrupted()) {
            Log.e(TAG, "socket listener terminated", e);
        }
    } finally {
        try {
            if (serverSocket != null) {
                serverSocket.close();
            }
            if (threadPool != null) {
                threadPool.shutdownNow();
            }
            Log.i(TAG, "socket listener stopped");
        } catch (IOException e) {
        }
    }
} 

public void stopSocketServer() {
    if (serverSocket != null) {
        try {
            // mark thread as interrupted
            interrupt();

            // now send connect request to myself to trigger leaving accept()
            LocalSocket ls = new LocalSocket();
            ls.connect(serverSocket.getLocalSocketAddress());
            ls.close();
        } catch (IOException e) {
            Log.e(TAG, "stopSocketServer failed", e);
        }
    }
}

Answer 2

从您发布的代码来看，您的LocalServerSocket server看起来永远是null而onDestroy()不会将其关闭。 另外，关闭套接字通常不应引发IOException-但是，如果同时关闭套接字， accept()会抛出该异常。