Socket，多个App使用同一端口遇到的坑

注意： 写该文章主要帮助自己记忆，贴出来希望可以给有同样问题的人解惑，不喜勿喷，可以提意见哦。

问题：java.net.BindException: bind failed: EADDRINUSE (Address already in use)

需求：两个应用需要访问同一个端口，获取相关信息。

策略：应用A可见的时候发送广播，应用B接收到广播后，断开端口，然后应用B绑定广播，其实看起了挺容易的，但足足花了大半天时间排除这个问题。

一、具体代码如下：应用A与应用B中绑定端口和断开端口的代码非常相似，这里就只贴应用A中的相关代码。

（1）应用A中的Application相关代码：

 public class CustomApplication extends Application {
  ...
//Apllication实现了registerActivityLifecycleCallbacks，当应用中的任何
//Activity处于可见的状态，即onStart()方法被调用时，
//Application的中的onActivityStarted(...)方法就会被调用,因此，在这里就可以发送广播给应用B。
//当应用中的任何Activity不可见的时候，即onStop调用的时，即onStop方法被调用。
  registerActivityLifecycleCallbacks(new ActivityLifecycleCallbacks() {

        ...
        @Override
        public void onActivityStopped(Activity activity) {
         
        }

        @Override
        public void onActivityStarted(Activity activity) {
         
              //这里发送广播是为了让应用B断开端口
                new Handler().postDelayed(new Runnable() {
                    @Override
                    public void run() {
                        //发送广播让应用B去断开端口。
                        String broadcastIntent = "com.kuju.closelocalsevicebroadcast";
                        Intent intent = new Intent(broadcastIntent);
                        intent.putExtra("tag","appA");
                        mContext.sendBroadcast(intent);
                    }
                }, 500);
                //延迟一定时间 保证发送广播后 别的应用杀掉服务后释放了端口
               //延迟2s是为了应用B有充足的时间断开端口。
               //应用A开始绑定端口
                new Handler().postDelayed(new Runnable() {
                    @Override
                    public void run() {
                        //Utils.isServiceWork判断ConnectPortService是否启动,没有启动才会重新启动。
                        if (!Utils.isServiceWork(mContext, "com.smarthome.app.service.ConnectPortService")) {
                            Intent intent = new Intent(mContext, LocalControlService.class);//重启LocalControlService
                            mContext.startService(intent1);
                            Logger.e(TAG, "重启LocalControlService");
                        }
                    }
                }, 2000);

}

（2）应用A中Utils.Java的相关代码：

  public class Utils {
  //判断当前的Service是否正在运行
  public static boolean isServiceWork(Context mContext, String serviceName) {
    boolean isWork = false;
    ActivityManager myAM = (ActivityManager) mContext
            .getSystemService(Context.ACTIVITY_SERVICE);
     //40并不是一个固定的值，这个数字需要更加应用开启的服务来定。
    List<ActivityManager.RunningServiceInfo> myList = myAM.getRunningServices(40);
    if (myList.size() <= 0) {
        return false;
    }
    for (int i = 0; i < myList.size(); i++) {
        String mName = myList.get(i).service.getClassName().toString();
        if (mName.equals(serviceName)) {
            isWork = true;
            break;
        }
    }
    return isWork;
}}

（4）应用A中服务ConnectPortService绑定与断开端口的代码

public class ConnectPortService extends Service {
//全局静态变量用于退出线程
private static boolean exit = false;
private static final String ACTION = "com.kuju.closelocalsevicebroadcast";
private BroadcastReceiver receiver;
//用于存储所有的Sockect，当接收到广播的时候，全部关掉。
private List<Socket> mSocketList=new ArrayList<>();
//服务端的套接字
private ServerSocket ssListenSocket = null;

@Override
public void onCreate() {
    super.onCreate();
        //注册广播
        IntentFilter filter = new IntentFilter();
        filter.addAction(ACTION);
        registerReceiver(receiver, filter);
        //开启监听Socket线程
        new ListenSocketHandler().start();
}

class ListenSocketHandler extends Thread {
    @Override
    public void run() {
        try {
            if (ssListenSocket == null) {
                ssListenSocket = new ServerSocket()；
                ssListenSocket.bind(new InetSocketAddress("监听的端口号"));
                while (!exit) { 
                    //ssListenSocket.accept();是同步操作的，如果没有Socket会一直阻塞
                    Socket s = ssListenSocket.accept();
                    Runnable r = new ThreadedEchoHandler(s);
                    Thread t = new Thread(r);
                    t.start();
                }
            }
        } catch (final IOException o) {
            handler.post(new Runnable() {
                @Override
                public void run() {
                    Log.d("Tests", "exception="+o.toString());
                }
            });
            o.printStackTrace();
        } finally {
            handler.post(new Runnable() {
                @Override
                public void run() {
                    Log.d("Tests", "finally");
                }
            });
            if (ssListenSocket != null) {
                try {
                    ssListenSocket.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

class ThreadedEchoHandler implements Runnable {
    private Socket socket;
    public ThreadedEchoHandler(Socket socket) {
        this.socket = socket;
        mSocketList.add(socket);
    }
    @Override
    public void run() {
        try {
            InputStream inputStream = socket.getInputStream();
            PrintStream printStream = new PrintStream(socket.getOutputStream(), true, "utf-8");
            byte buffer[] = new byte[1024 * 4];
            int temp = 0;
            StringBuffer stringBuffer = new StringBuffer();
            //从InputStream当中读取Gateway发送的数据
            while ((temp = inputStream.read(buffer)) != -1) {
                String command = new String(buffer, 0, temp);
                if (command.substring(command.length() - 3).equals("@#$")) {
                    stringBuffer.append(command.substring(0, command.length() - 3));
                    break;
                }
                stringBuffer.append(command);
            }
       ...
        } catch (IOException e) {
                e.printStackTrace();
        } finally {
            try {
                socket.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}
@Override
public void onDestroy() {
    super.onDestroy();
    exit = true;
    ssListenSocket =null;  
   if(receiver!=null){
        unregisterReceiver(receiver);
    }
}

public class CloseLocalServiceBroadReceiver extends BroadcastReceiver {
    @Override
    public void onReceive(final Context context, final Intent intent) { 
             //表示本应用发送的广播不会接收到，只有其他应用发送的才会执行以下代码
              if(intent.hasExtra("tag")){
                if(!"appA".equals(intent.getStringExtra("tag"))){
                //为了防止Socket没有及时端口，所以统一断开
                for(int i=0;i<mSocketList.size();i++){
                    try {
                        mSocketList.get(i).close();
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
                //调用stopSelf服务会销毁，因此会调用onDestory()方法。
                stopSelf();
            }}
      }
    }
}}

二、应用B中是同样的实现方式，只是发送广播带的标签和接收代码有点区别。
（1）发送广播的代码：

  //这里发送广播是为了让应用A断开端口
            new Handler().postDelayed(new Runnable() {
                @Override
                public void run() {
                    //发送广播让应用A去断开端口。
                    String broadcastIntent = "com.kuju.closelocalsevicebroadcast";
                    Intent intent = new Intent(broadcastIntent);
                    //应用B与应用A不同之处就是带的便签不一样
                    intent.putExtra("tag","appB");
                    mContext.sendBroadcast(intent);
                }
            }, 500);

（2）接收广播的代码：

public class CloseLocalServiceBroadReceiver extends BroadcastReceiver {
@Override
public void onReceive(final Context context, final Intent intent) { 
         //表示本应用发送的广播不会接收到，只有其他应用发送的才会执行以下代码
          if(intent.hasExtra("tag")){
            if(!"appB".equals(intent.getStringExtra("tag"))){
            //为了防止Socket没有及时端口，所以统一断开
            for(int i=0;i<mSocketList.size();i++){
                try {
                    mSocketList.get(i).close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            //调用stopSelf服务会销毁，因此会调用onDestory()方法。
            stopSelf();
        }}
  }
}}

通过查看代码确实没有什么问题，但是这里有个非常大的坑，就是在onDestory中exit设置为true了，但是线程中一直没有走finally方法，导致ServiceSocket一直没有断开，其他应用在启动的时候就会出现问题，如下所示：

java.net.BindException: bind failed: EADDRINUSE (Address already in use)

原因：主要是因为ServiceSocket.accept()没有获取到Socket时，会一直阻塞，导致后面的代码根本就没有执行，所以即使在onDestory中设置exit=true,也没有用处。

解决办法：

在ConnectPortService的onDestory()方法中必须主动关闭ServiceSocket，如下所示：

  if (ssListenSocket != null) {
       try {
           ssListenSocket.close();
            ssListenSocket = null;
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

重要提示：

应用A与应用B重复使用了相同的代码，如果公司接了很多单，需要帮不同的公司定制App，但是功能都相同，如果每一套代码都重复利用相同的代码，这样不仅浪费时间，而且还增加维护成本。所以可以把相同的功能封装成一个jar，以后不同的App直接调用功能jar就行了。