中国移动项目，底层开发。

首先描述一下问题。
刚开始能发出少量的数据，接受少量的数据。
到后来不能发出数据，接受少量的数据。
最后不能发出数据，也接受不到数据。
socket链接也没抛出异常。真是疯了！
发送数据的线程。

syncUpDataSendThread = new Thread(id + " 异步上行数据发送") {

/*
* (non-Javadoc)
*
* @see java.lang.Thread#run()
*/
public void run() {
try {
while (true) {
if (out == null) {
if (connected) {
sleep(cfg.reTryToSendTime);
} else {
sleep(50);
}
continue;
}
// byte[] data = upDataQueue.poll(30, TimeUnit.SECONDS);
try {
byte[] data = upDataQueue
.poll(30, TimeUnit.SECONDS);
if (data != null) {
out.write(data);
if (cfg.enableLog) {
Logoo.info("发送数据：" + new String(data));
}
Logoo.debug("发送数据长度：" + data.length);
} else {
// 读取上行数据超时
}
} catch (SocketTimeoutException e) {
// e.printStackTrace();
Logoo.warn("Socket连接超时异常", e);

} catch (IOException e) {
// e.printStackTrace();
Logoo.warn("发送数据发生IO异常", e);
SocketUtils.close(socket, in, out);
in = null;
out = null;
socket = null;
connected = false;
} catch (NullPointerException e) {
// e.printStackTrace();
Logoo.warn("读取数据异常", e);
SocketUtils.close(socket, in, out);
in = null;
out = null;
socket = null;
connected = false;
}
}
} catch (InterruptedException e) {
Logoo.error(id + " 异步上行数据发送被异常中断，服务已经不可用了，无法继续进行协议转换收发", e);
}
}
};

asyncUpDataSendThread.setDaemon(true);


接受数据的线程。
public void run() {

while (true) {// 循环重连
// 每次重连循环前清空占用的连接资源
SocketUtils.close(socket, in, out);
in = null;
out = null;
socket = null;
connected = false;

// 连接就绪门闩
if (connectionReadyLatch.getCount() == 0) {
connectionReadyLatch = new CountDownLatch(1);
}
socket = new Socket();

// 设置访问超时时间
try {
socket.setSoTimeout(cfg.socketTimeout);
// Logoo.debug(name + " 尝试连接到服务器：" + address);
Logoo.debug(id + " 尝试连接到东软接入网关服务器：" + address);
socket.connect(address, cfg.socketTimeout);
Logoo.info(id + " 连接东软接入网关服务器：" + address + " 成功 ...");

out = socket.getOutputStream();
in = socket.getInputStream();

// 门闩开启，可以访问相关资源了
connectionReadyLatch.countDown();
connected = true;
Looker.on(NeusoftGateProtocol.class, "网关连接情况");
bindAfterConnected();
while (true) {// 循环读取数据
if (out == null) {
break;
}
// 分配数据头空间
byte[] heads = new byte[NeusoftGateProtocolConstants.PACK_HEAD_LEN];
try {
int headReaded = in.read(heads);
if (headReaded <= 0) {
if (isBinding) {
try {
sleep(500);
} catch (InterruptedException e) {
Logoo.error("", e);
}
continue;
} else {
// 连接被远程断开，需要重连
Logoo.warn(id + " 到东软接入网关服务器 " + address
+ " 的连接被远程断开！");
Looker.off(NeusoftGateProtocol.class, "网关连接情况");
break;
}
}
// 接收到数据后进行持活通知
aliveCheck.touch();
if (cfg.enableLog) {
Logoo.info("读取数据头：" + new String(heads));
}
Logoo.debug("读取数据头长度：" + heads.length);

if (headReaded == NeusoftGateProtocolConstants.PACK_HEAD_LEN) {
// 获取到网关的回应，需要进行解析
// 数据包长度 8 ASCII整数
// 命令字 4 ASCII整数
// 状态码 4 ASCII整数
// 序列号 4 ASCII整数
String downDataLenStr = new String(
heads,
0,
NeusoftGateProtocolConstants.PACK_LENGTH_SEG_LEN);
int downDataLen = NumberFormator
.parseInt(downDataLenStr);

byte[] cmd = new byte[NeusoftGateProtocolConstants.PACK_CMD_SEG_LEN];
System
.arraycopy(
heads,
8,
cmd,
0,
NeusoftGateProtocolConstants.PACK_CMD_SEG_LEN);

byte[] code = new byte[NeusoftGateProtocolConstants.PACK_CODE_SEG_LEN];
System
.arraycopy(
heads,
12,
code,
0,
NeusoftGateProtocolConstants.PACK_CODE_SEG_LEN);

String seqStr = new String(
heads,
NeusoftGateProtocolConstants.PACK_HEAD_LEN
- NeusoftGateProtocolConstants.PACK_SEQ_SEG_LEN,
NeusoftGateProtocolConstants.PACK_SEQ_SEG_LEN);
int seq = NumberFormator.parseInt(seqStr);

// 如果是命令异步投递报文，那么开始解析数据并且投递
if (Arrays
.equals(
cmd,
NeusoftGateProtocolConstants.CMD_POST_DATA_DOWN)) {
if (downDataLen > 1024) {
Logoo.warn("向业务系统透传终端上传的数据包downDataLen："
+ downDataLen);
}
byte[] bodys = new byte[downDataLen
- NeusoftGateProtocolConstants.PACK_HEAD_LEN];
int bodyReaded = in.read(bodys);
if (bodyReaded <= 0) {
// 连接被远程断开，需要重连
Logoo.warn(id + " 到东软接入网关服务器 " + address
+ " 的连接被远程断开！");
Looker.off(NeusoftGateProtocol.class,
"网关连接情况");
break;
}
if (cfg.enableLog) {
// Logoo
// .info("读取异步投递数据体："
// + new String(bodys));
}
Logoo.debug("读取异步投递数据体长度：" + heads.length);
if (bodyReaded == downDataLen
- NeusoftGateProtocolConstants.PACK_HEAD_LEN) {
int bodyDataLen = downDataLen
- NeusoftGateProtocolConstants.PACK_HEAD_LEN
- 28;
byte[] bodyData = new byte[bodyDataLen];
// FIXME
// 这个读取出来的目标标识是接入网关数据，而非协议中数据，需要使用协议中数据
// ，而非网关数据，依赖终端协议，而非网关协议（2009-2-18佘士东）
String targetId = new String(
bodys,
0,
NeusoftGateProtocolConstants.PACK_TARGET_ID_LEN - 1)
.trim();
System.arraycopy(bodys, 28, bodyData, 0,
bodyDataLen);
if (protocolConvertor.isPacket(bodyData)) {
asyncPacketThreadPool
.execute(new AsyncPacketWorker(
bodyData));
Looker.note(getClass(), "解析中的异步报文数",
asyncPacketThreadPool
.getActiveCount());
// try {
// List<IPacket> packet =
// protocolConvertor
// .convertPackets(bodyData);
// for (IPacket pack : packet) {
// protocolCallback.packet(pack);
// }
// } catch (ProtocolConvertorException
// e) {
// Logoo.warn("转换报文异常", e);
// continue;
// }
} else if (protocolConvertor
.isCommandResponse(bodyData)) {
try {
protocolCallback
.commandResponse(protocolConvertor
.convert(bodyData));
} catch (ProtocolConvertorException e) {
// e.printStackTrace();
Logoo.warn("", e);
continue;
}
} else {
// 未知数据类型，放弃进行转换输出
Logoo.warn("错误的上行数据："
+ new String(bodyData));
}

} else {
// 数据体长度不足，与报文头中给定长度不同
Logoo.warn("");
}
} else if (Arrays.equals(cmd,
NeusoftGateProtocolConstants.CMD_ACTIVE_UP)) {
Logoo.debug("(从网关)收到链路维护报文："
+ new String(heads));
// 如果是服务端发来的链路维持报文那么将其中的索引为8的字节变为'1'就可以了
heads[NeusoftGateProtocolConstants.PACK_LENGTH_SEG_LEN] = NeusoftGateProtocolConstants.CMD_DOWN_TAG;
// 写回数据，进行持活
out.write(heads);
Logoo.debug("回应(到网关)链路维护报文："
+ new String(heads));
} else {
// 如果是下行回应包，那么进入回应数据响应中
if (cmd[0] == NeusoftGateProtocolConstants.CMD_DOWN_TAG) {
CountDownLatch waitLatch = upDataResponseWaitMap
.remove(seq);
if (waitLatch != null) {
int responseDataLen = downDataLen
- NeusoftGateProtocolConstants.PACK_HEAD_LEN;
if (responseDataLen > 0) {
byte[] responseData = new byte[responseDataLen];
int responseReaded = in
.read(responseData);
if (responseReaded <= 0) {
// 连接被远程断开，需要重连
Logoo.warn(id + " 到东软接入网关服务器 "
+ address
+ " 的连接被远程断开！");
Looker
.off(
NeusoftGateProtocol.class,
"网关连接情况");
break;
}
if (cfg.enableLog) {
Logoo

.info("读取回应数据头："
+ new String(heads));
}
Logoo.debug("读取回应数据头长度："
+ heads.length);
if (responseReaded == responseDataLen) {
responseDataMap.put(seq,
responseData);
responseStatusMap
.put(seq, code);
} else {
// 数据体读取无效，返回状态为丢失回应
responseStatusMap
.put(
seq,
NeusoftGateProtocolConstants.CODE_LOOSE_RESPONSE);
}
} else {
responseStatusMap.put(seq, code);
}
waitLatch.countDown();
} else {
// 没有请求在等待，回应超时，已经无效
Logoo.warn("回应超时");
}
} else {
// 如果是上行包到这里，就很奇怪，呵呵，异常输出的干活
// 当然如果是持活，那么就给出持活回应
Logoo.warn("错误的上行包数据：" + new String(cmd));
}
}
} else {
// 读取数据长度不足组装一个头部
Logoo.warn("");
}
} catch (SocketTimeoutException e) {
// e.printStackTrace();
// Logoo.warn("读入对象超时，进入下一次循环", e);
}
}
} catch (SocketTimeoutException e) {
Logoo.warn("连接东软接入网关超时，10秒后重试 ...");
Looker.off(NeusoftGateProtocol.class, "网关连接情况");
} catch (ConnectException e) {
try {
sleep(cfg.reConnectTime);
} catch (InterruptedException e1) {
break;
}
} catch (IOException e) {
// e.printStackTrace();
Logoo.warn(id + " 网络异常，断开连接，准备重连 ...", e);
Looker.off(NeusoftGateProtocol.class, "网关连接情况");
try {
sleep(cfg.reConnectTime);
} catch (InterruptedException e1) {
// e1.printStackTrace();
break;
}
} catch (NullPointerException e) {
// e.printStackTrace();
Logoo.warn(id + " 网络数据交换发生空指针异常，断开连接，准备重连 ...", e);
Looker.off(NeusoftGateProtocol.class, "网关连接情况");
SocketUtils.close(socket, in, out);
in = null;
out = null;
socket = null;
connected = false;
}
}
}