关于Android socket通信，可以向服务器发送消息，但是无法读取消息

[解牛之术]

完整代码如下：
package com.doctor.doctorhelper.ui.document;

import android.annotation.SuppressLint;
import android.app.Service;
import android.content.Intent;
import android.os.Handler;
import android.os.IBinder;
import android.os.RemoteException;
import android.os.StrictMode;
import android.text.TextUtils;
import android.util.Log;

import com.doctor.doctorhelper.IBackService;
import com.doctor.doctorhelper.application.ConfigUrl;
import com.doctor.doctorhelper.utils.UIHelper;
import com.doctor.doctorhelper.utils.Utils;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.lang.ref.WeakReference;
import java.net.Socket;
import java.net.UnknownHostException;
import java.util.Arrays;


public class BackService extends Service {
private static final String TAG = "BackService";
/** 心跳检测时间 */
private static final long HEART_BEAT_RATE = 3* 1000;
/** 主机IP地址 */
private static String HOST = "192.168.1.30";
/** 端口号 */
public static final int PORT =10801;
/** 消息广播 */
public static final String MESSAGE_ACTION = "org.feng.message_ACTION";
/** 心跳广播 */
public static final String HEART_BEAT_ACTION = "org.feng.heart_beat_ACTION";

private long sendTime = 0L;

/** 弱引用 在引用对象的同时允许对垃圾对象进行回收 */
// private WeakReference<Socket> mSocket;
private Socket socket;

private ReadThread mReadThread;

private IBackService.Stub iBackService = new IBackService.Stub() {
@Override
public boolean sendMessage(String message) throws RemoteException {
return sendMsg(message);
}
};

@Override
public IBinder onBind(Intent arg0) {
return (IBinder) iBackService;
}

@Override
public void onCreate() {
super.onCreate();
HOST= (String) Utils.getShare(this, ConfigUrl.SERVER_IP,"ip");
Log.i(TAG,"ip-->"+HOST);
Log.i(TAG,"port-->"+PORT);
new InitSocketThread().start();
}

// 发送心跳包
private Handler mHandler = new Handler();
private Runnable heartBeatRunnable = new Runnable() {
@Override
public void run() {
if (System.currentTimeMillis() - sendTime >= HEART_BEAT_RATE) {
boolean isSuccess = sendMsg("mdc_connect");// 就发送一个\r\n过去, 如果发送失败，就重新初始化一个socket
if (!isSuccess) {//此时消息发送失败
mHandler.removeCallbacks(heartBeatRunnable);
mReadThread.release();
releaseLastSocket(socket);
//new InitSocketThread().start();
}
}
mHandler.postDelayed(this, HEART_BEAT_RATE);
}
};

public boolean sendMsg(String msg) {
if (null == socket) {
return false;
}
try {
if (!socket.isClosed() && !socket.isOutputShutdown()) {
OutputStream os = socket.getOutputStream();
os.write(msg.getBytes());
os.flush();
//os.close();
sendTime = System.currentTimeMillis();// 每次发送成功数据，就改一下最后成功发送的时间，节省心跳间隔时间
Log.i(TAG, "发送成功的时间：" + sendTime);
} else {
return false;
}
} catch (IOException e) {
e.printStackTrace();
Intent intent = new Intent(HEART_BEAT_ACTION);
intent.putExtra("message", "exit");
sendBroadcast(intent);
Log.i(TAG,"send-->"+e.getMessage());
return false;
}
return true;
}

// 初始化socket
private void initSocket() throws UnknownHostException, IOException {
socket = new Socket(HOST, PORT);
socket.setSoTimeout(13000);//?
if (socket.isConnected()){//连接成功
//sendMsg("mdc_"+Utils.getShare(this,ConfigUrl.DEVICE_ID,"手机设备id"));
/* Intent intent = new Intent(HEART_BEAT_ACTION);
intent.putExtra("message", "success");
sendBroadcast(intent);*/
if (sendMsg("mdc_"+Utils.getShare(this,ConfigUrl.DEVICE_ID,"手机设备id"))){//发送成功
//接收服务器返回的信息
mReadThread = new ReadThread(socket);
mReadThread.start();
}
}
/* mReadThread = new ReadThread(socket);
mReadThread.start();*/
//mHandler.postDelayed(heartBeatRunnable, HEART_BEAT_RATE);// 初始化成功后，就准备发送心跳
}

// 释放socket
private void releaseLastSocket(Socket mSocket) {
try {
if (null != mSocket) {
if (!mSocket.isClosed()) {
mSocket.close();
}
mSocket = null;
}
} catch (IOException e) {
e.printStackTrace();
}
}

class InitSocketThread extends Thread {
@Override
public void run() {
super.run();
try {
initSocket();
} catch (UnknownHostException e) {
e.printStackTrace();
Log.i(TAG,"socket-->"+e.getMessage());
Log.i(TAG,"连接失败");
Intent intent = new Intent(HEART_BEAT_ACTION);
intent.putExtra("message", "fail");
sendBroadcast(intent);
} catch (IOException e) {
e.printStackTrace();
Log.i(TAG,"socket-->"+e.getMessage());
Intent intent = new Intent(HEART_BEAT_ACTION);
intent.putExtra("message", "fail");
sendBroadcast(intent);
}
}
}

public class ReadThread extends Thread {
private Socket rSocket;
private boolean isStart = true;

public ReadThread(Socket socket) {
rSocket=socket;
}

public void release() {
isStart = false;
releaseLastSocket(rSocket);
}

@SuppressLint("NewApi")
@Override
public void run() {
super.run();
String line="";
//Socket socket = mWeakSocket.get();
if (null != rSocket) {
while (isStart&&!rSocket.isClosed()&&!rSocket.isInputShutdown()){
/* if (DocumentActivity.isExit){
Log.i("BackService","DocumentActivity.isExit-->"+DocumentActivity.isExit);
break;
}*/
try {
Log.i(TAG,"开始读取消息");
BufferedReader in=new BufferedReader(new InputStreamReader(rSocket.getInputStream()));
line=in.readLine();
//in.close();
Log.i(TAG,"line-->"+line);
if (line!=null){
Log.i(TAG, "收到服务器发送来的消息："+line);
if ("mdc_ok".equals(line)||"mdc_exist".equals(line)){
mHandler.postDelayed(heartBeatRunnable, HEART_BEAT_RATE);// 初始化成功后，就准备发送心跳
return;
}
}else if (line==null){
Log.i(TAG, "服务器发送过来的消息是空的");
}
/* while ((line=in.readLine())!=null){
Log.i(TAG, "收到服务器发送来的消息："+line);
*//* if ("exit".equals(line)){//退出
Intent intent = new Intent(HEART_BEAT_ACTION);
intent.putExtra("message", line);
sendBroadcast(intent);
}*//*
if ("mdc_ok".equals(line)||"mdc_exist".equals(line)){
mHandler.postDelayed(heartBeatRunnable, HEART_BEAT_RATE);// 初始化成功后，就准备发送心跳
return;
}
}*/

} catch (IOException e) {
Log.i(TAG,"Read-->"+e.getClass().getName());
e.printStackTrace();
continue;
}


}

}
}
}

@Override
public void onDestroy() {
super.onDestroy();
Log.i(TAG,"onDestroy");
mHandler.removeCallbacks(heartBeatRunnable);
mReadThread.release();
releaseLastSocket(socket);
}
}
求大神

[解牛之术]

解决了，是服务器那边的问题