socketmanager.java

java程序五子棋源代码。 java程序五子棋源代码。

package com.tianxia.qipai.model.socket;

import java.io.DataInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import javax.microedition.io.ConnectionNotFoundException;
import javax.microedition.io.Connector;
import javax.microedition.io.SocketConnection;
import com.tianxia.qipai.model.util.StringTokenizer;
import com.tianxia.qipai.model.util.*;

public class SocketManager extends Thread {    //socket连接的维护实现
	private String  ipstring;
	private String  recpacket;
	private SocketInterface socketinterface;
	long now,recent,recentcheck;   //now 表示当前时间，recent表示最近一次socket连接的时间
	private InputStream is;
	private static SocketManager instance;
	private OutputStream os;
	private SocketConnection sc;
	private boolean Ifthreadstart;    //线程启动标志
	private boolean connectflag;
	private boolean toconnectflag;
	private boolean havesenddata;
	private boolean switchstate;  //是否正在切换服务器
	private boolean runflag = true;
	private String senddata;
	private final static int maxcount = 3;//socket最大连续重连失败次数
	private int reconnectcount;  //socket重连次数
	private boolean reconnectflag;//socket重连标志
	private String buffdata ="";  //用于断线缓存
	public final static String ireconnect = "998";  //与服务器重新连接成功
	public final static String itoreconnect = "997";//与服务器断开，正重新连接
	public final static String idisconnect = "996";//无法连接服务器
    //监测运行时，以便及时运行垃圾回收
	private Runtime rt = null;
	private boolean gcflag = false;  //是否要肩负起垃圾收集工作
	/**
	 * 
	 */
	

	public SocketManager(boolean gcflag) {
		super();
		this.gcflag = gcflag;
		// TODO 自动生成构造函数存根
	}
	public void init(SocketInterface socketinterface,String ipstring){
		this.socketinterface = socketinterface;
		this.ipstring = ipstring;
		connectflag = false;
		Ifthreadstart = false;
		reconnectflag = false;
		toconnectflag = false;
		havesenddata = false;
		switchstate = false;
		this.start();
	}
	
	
	public void resetipstring(String ipstring){   //重新设置连接的ip参数
		switchstate = true;
		this.ipstring = ipstring;
		connectflag = false;
		try{
			sc.close();
		} catch(IOException e){
			e.printStackTrace();
		}
		switchstate = false;
		
	}
	
	public void resetSocInterface(SocketInterface socketinterface){    //重新设置调用这个socket的父级句柄
		this.socketinterface = socketinterface;
	}

	public static synchronized SocketManager getInstance(){
		if(instance == null){
			instance = new SocketManager(false);
		}
			return instance;
	}
	

	public void run() {
		// TODO 自动生成方法存根
		while(!toconnectflag)
		{
			try {
				Thread.sleep(100);
			} catch (InterruptedException e) {
				// TODO 自动生成 catch 块
				e.printStackTrace();
			}
		}
		long gap = 0;   //时间差
		if (connect()) {
			recent = System.currentTimeMillis();
			recentcheck = System.currentTimeMillis();
			now = System.currentTimeMillis();
			while (runflag) {
				if(!switchstate){   //处在同一服务器
					if (havesenddata){  //连接发送的第一个数据包  
							sendpacket(senddata,false);
							havesenddata = false;
						}
						if (connectflag) {
							if (receivepacket())
								datatofather();
							try {
								now = System.currentTimeMillis();
								gap = (now - recent)/1000;
								if(gap > 60*3){   //如果超过3分钟没收到数据，表示连接已经断开，需要重连
									disconnect();   //断开连接
									
								}
								gap = (now - recentcheck)/1000;
								if(gap > 30){   //每隔30秒发送一次检测包
									sendpacket(UniversalDefine.CHECKDATABAG,false);
									recentcheck = System.currentTimeMillis();
								}
								
								Thread.sleep(1000);
							} catch (InterruptedException e) {
								// TODO 自动生成 catch 块
								e.printStackTrace();
							}
						}else{
							recpacket = "000|"+itoreconnect;   //与服务器断开连接
							datatofather();
							if(connect()){
								recpacket = "000|"+ireconnect;   //服务器重连成功
								sendpacket(buffdata,true);
								datatofather();
							}else{
								recpacket = "000|"+idisconnect;  //无法连接服务器
								datatofather();
								break;
							}
							
						}
						
				}
				else{
					try {
						Thread.sleep(1000);
					} catch (InterruptedException e) {
						// TODO 自动生成 catch 块
						e.printStackTrace();
					}
					
				}
				if(gcflag){  //判断是否有垃圾回收任务
					 //监测运行时，以便及时运行垃圾回收
					rt = Runtime.getRuntime();
				//在性能过耗（可用内存不到当前内存总量的2/3时），进行垃圾回收GC
					System.out.println("freeMory:  "+String.valueOf(rt.freeMemory()));
					System.out.println("totalMory:  "+String.valueOf(rt.totalMemory()));
					if(rt.freeMemory() < (rt.totalMemory() * 2/3)){
			            rt.gc();
			            //System.out.println("freeMory1:  "+String.valueOf(rt.freeMemory()));
						//System.out.println("totalMory1:  "+String.valueOf(rt.totalMemory()));
			        }
				}
			    
			}
				
		}else{
			recpacket = "000|"+idisconnect;  //无法连接服务器
			datatofather();
		}
		
	}

	//断开连接
	private void disconnect(){
		try {
			if(sc != null){
				sc.close();
			}
			
		} catch (IOException e) {
			// TODO 自动生成 catch 块
			e.printStackTrace();
		}
		connectflag = false;
	}
	
	private void setsendpacket(String packetdata){
		senddata = packetdata;
		havesenddata = true;
		toconnectflag = true;
	}
	// 向服务器发送数据
	public  void sendpacket(String packetdata,boolean ifbuff) {
		if(ifbuff){  //是否将数据缓存
			buffdata = packetdata;
		}
		if(!toconnectflag){
			setsendpacket(packetdata);
		}else if (connectflag){
			try {
				os.write(packetdata.getBytes());
				//System.out.println(packetdata);
			} catch (Exception oe) {
				disconnect();
				//System.out.println("socket 连接已断开");
				return;
			}
		}
			
	}

	// 连接服务器
	private boolean connect() {
		if(!connectflag){
			try {
				if(sc != null){
					sc.close();
				}
				sc = (SocketConnection) Connector.open(ipstring);
				is = sc.openInputStream();
				os = sc.openOutputStream();
				connectflag = true;
				if(!reconnectflag){
					//System.out.println("socket connect successful");
					reconnectflag = true;
				}else{
					//System.out.println("socket reconnect successful");
				}
				
		
			} catch (ConnectionNotFoundException cnfe) {
				reconnectcount++;
				try {
					Thread.sleep(1000);
				} catch (InterruptedException e) {
					// TODO 自动生成 catch 块
					e.printStackTrace();
				}
				if(reconnectcount>=maxcount){
					return false;
				}else{
					return connect();
				}
				
			} catch (IOException ioe) {
				if (!connectflag) {
					ioe.printStackTrace();
					return false;
				}
			} catch (Exception e) {
				e.printStackTrace();
				return false;
			}
			
			
		}
		return true;
	}

	
	// 从服务器接收数据
	private boolean receivepacket() {
	  try {
			recpacket = "";
			DataInputStream dis = new DataInputStream(is);
			int length = dis.available();
			byte[] reponseBytes = new byte[length];
			dis.read(reponseBytes);
			recpacket = new String(reponseBytes);
			System.out.println("Received . :" + recpacket);

		} catch (IOException ioe) {
			ioe.printStackTrace();

		}
		if (recpacket.length() == 0)
			return false;
		else
			recent = System.currentTimeMillis();
		
		return true;
	}

	
	// 把接收到的数据做初步解析后，山选出业务数据分发给相应的处理模块
	private void datatofather() {
		int ifcheck=999;   //检测包标志999 为检测包  997/998 表示socket连接已经断开/连接上 其他 为业务数据包 
		String tempdata="";
		
		StringTokenizer datatokenizer = new StringTokenizer(recpacket, UniversalDefine.DATADIVISION);
		while(datatokenizer.hasMoreTokens()){
				ifcheck=999;
				tempdata = datatokenizer.nextToken();
				StringTokenizer stringtokenizer = new StringTokenizer(tempdata, UniversalDefine.DIVISION);
				if(stringtokenizer.hasMoreTokens())
					if(stringtokenizer.nextToken().equals("000")){
						if (stringtokenizer.hasMoreTokens()) {
							ifcheck = Integer.parseInt(stringtokenizer.nextToken());
							
						}
						if(ifcheck != 999 && !tempdata.equals("")){//不是检测包
							socketinterface.RecvieData(tempdata);			
							
						}
					}
				
			}
		
	}

	// 启动socketmanager实例线程,并保证socket连接已经建立
	public  void socketthreadstart() {
		if (!Ifthreadstart){
			Ifthreadstart = true;
	
			this.start();
			while(!connectflag){
				try {
					Thread.sleep(1000);
				} catch (InterruptedException e) {
					// TODO 自动生成 catch 块
					e.printStackTrace();
				}
			}
			
		}
	}
	
	
	public void setNull(){
		runflag = false;
		socketinterface = null;
		try {
			sc.close();
		} catch (IOException e) {
			// TODO 自动生成 catch 块
			e.printStackTrace();
		}
		is=null;
		os = null;
		instance = null;
	}

}