tcp长连接中客户端重连

在tcp长连接时候，客户端重连，需要将原来的资源释放，关闭原来的读取消息的线程，和socket，重新调用心跳线程

如何清理资源:

将超时的心跳线程停止，可以在心跳线程的外面，加上一个while(boolean flag)循环，

将flag置false，将心跳线程停止

停止读取消息的线程，关闭套接字

代码如下:

package cn.erong.socket;

import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.IOException;
import java.net.InetSocketAddress;
import java.net.Socket;
import java.net.UnknownHostException;

public class ClientConnectAgain {
	private final String SOCKET_HOST = "127.0.0.1";
	private final int SOCKET_PORT = 8888;
	private Socket mSocket;
	private DataOutputStream mDataOutputStream;
	private SocketReadThread mReadThread;
	private void connectToServer() {  
	       Thread connectThread = new Thread(new Runnable() {  
	           public void run() {  
	               try {  
	                   mSocket = new Socket();  
	                   mSocket.connect(  
	                           new InetSocketAddress(SOCKET_HOST, SOCKET_PORT));  
	  
	                   mDataOutputStream = new DataOutputStream(  
	                           mSocket.getOutputStream());  
	                     
	                   // 开启线程负责读取服务端数据  
	                   mReadThread = new SocketReadThread();  
	                   mReadThread.start();  
	                     
	                   // 心跳检测，检测socket是否连接  
//	                   mHandler.postDelayed(mHeartBeatRunnable, HEART_BEAT_RATE);  
	               } catch (UnknownHostException e) {  
	                   System.out.println("连接失败");  
	                   e.printStackTrace();  
	               } catch (IOException e) {  
	            	   System.out.println("连接失败");    
	                   e.printStackTrace();  
	               }  
	           }  
	       });  
	       connectThread.start();  
	   }
	
	
    // 心跳机制  
    private static final long HEART_BEAT_RATE = 4 * 1000;  
    private long sendTime = 0L;  
    private Runnable mHeartBeatRunnable = new Runnable() {  
  
        @Override  
        public void run() {  
            if (System.currentTimeMillis() - sendTime >= HEART_BEAT_RATE) {//每隔4秒检测一次  
                boolean isSuccess = sendHeartBeatMsg("");  
                if (!isSuccess) {  
                   System.out.println("连接已断开，正在重连……");  
//                    mHandler.removeCallbacks(mHeartBeatRunnable);// 移除线程，重连时保证该线程已停止上次调用时的工作  
                    mReadThread.release();//释放SocketReadThread线程资源  
                    releaseLastSocket();  
                    connectToServer();// 再次调用connectToServer方法，连接服务端  
                }  
            }  
//            mHandler.postDelayed(this, HEART_BEAT_RATE);  
        }  
    };  
    /** 
     * 发送心跳包 
     *  
     * @param msg 
     * @return 
     */  
    public boolean sendHeartBeatMsg(String msg) {  
        if (null == mSocket) {  
            return false;  
        }  
        try {  
            if (!mSocket.isClosed() && !mSocket.isOutputShutdown()) {  
                String message = msg + "\r\n";  
                mDataOutputStream.write(message.getBytes());  
                mDataOutputStream.flush();  
                sendTime = System.currentTimeMillis();  
            } else {  
                return false;  
            }  
        } catch (IOException e) {  
            e.printStackTrace();  
            return false;  
        }  
        return true;  
    }  
    
    class SocketReadThread extends Thread {  
    	  
        private static final String TAG = "SocketThread";  
        private volatile boolean mStopThread = false;  
        public void release() {  
            mStopThread = true;  
            releaseLastSocket();  
        }  
        @Override  
        public void run() {  
            DataInputStream mInputStream = null;  
            try {  
                mInputStream = new DataInputStream(mSocket.getInputStream());  
               System.out.println("SocketThread running!");  
                while (!mStopThread) {   
                    String resultStr = mInputStream.readUTF();  
                  System.out.println(resultStr); 
                }  
            } catch (UnknownHostException e) {  
                e.printStackTrace();  
            } catch (IOException e) {  
                e.printStackTrace();  
            } finally {  
                try {  
                    mSocket.close();  
                } catch (IOException e) {  
                    e.printStackTrace();  
                }  
                if (mInputStream != null) {  
                    try {  
                        mInputStream.close();  
                        mInputStream = null;  
                    } catch (IOException e) {  
                        e.printStackTrace();  
                    }  
                }  
            } 
        }
        }

    /** 
     * 断开连接 
     * 
     */  
       private void releaseLastSocket() {  
           try {  
               if (null != mSocket) {  
                   if (!mSocket.isClosed()) {  
                       mSocket.close();  
                   }  
               }  
               mSocket = null;  
           } catch (IOException e) {  
               e.printStackTrace();  
           }  
       }  
       
}

代码无法运行，只是简单说明下一些思路，转载自

http://blog.csdn.net/u011791526/article/details/53536403