通过线程监控socket服务器是否done机

现实中的socket可能会因为各种原因done机，但这么重要的服务器怎么能允许这种事情发生？这次我们就来通过一个线程去监控socket服务器，如果done机重新将其启动。

下面是监控项目和socket服务器项目的目录结构：

因为线程是每两秒发送一次请求检测服务器是否done机，类似心跳，所以包名起作heart。

来看客户端heart代码：

Entity 实体类：用来构建测试请求的数据结构

package heart;

import java.io.Serializable;

public class Entity implements Serializable {

    private static final long serialVersionUID = 1L;
    private String name;
    private String sex;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getSex() {
        return sex;
    }

    public void setSex(String sex) {
        this.sex = sex;
    }

    @Override
    public String toString() {
        return "Entity [name=" + name + ", sex=" + sex + "]";
    }

}

客户端同步线程代码：

package heart;

public class ClientHeart extends Thread {

    @Override
    public void run() {

        try {
            while (true) {
                ClientSender.getInstance().send();
                synchronized (ClientHeart.class) {
                    // this.wait(5000);
                    Thread.sleep(2000);
                }
            }

        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    /**
     * 程序的入口main方法
     *
     * @param args
     */
    public static void main(String[] args) {
        ClientHeart client = new ClientHeart();
        client.start();
    }

}

客户端发送消息代码：

package heart;

import java.io.ObjectOutputStream;
import java.net.InetAddress;
import java.net.Socket;

import echoserver.EchoServer;
import heart.Entity;

public class ClientSender {

    private ClientSender() {
    }

    Socket sender = null;
    private static ClientSender instance;

    public static ClientSender getInstance() {
        if (instance == null) {
            synchronized (ClientHeart.class) {
                instance = new ClientSender();
            }
        }
        return instance;
    }

    @SuppressWarnings("static-access")
    public void send() {
        try {
            sender = new Socket("192.168.1.166", 9090);

            while (true) {
                ObjectOutputStream out = new ObjectOutputStream(sender.getOutputStream());
                Entity obj = new Entity();
                obj.setName("xiaoming");
                obj.setSex("男");
                out.writeObject(obj);
                out.flush();

                System.out.println("已发送...");
                Thread.sleep(5000);
            }
        } catch (Exception e) {
            EchoServer myServer = new EchoServer();
            System.out.println("连接异常");
            try {
                myServer.main(null);
            } catch (Exception e1) {
                // TODO Auto-generated catch block
                e1.printStackTrace();
            }

        }
    }
}

发送消息代码中，可以看到socket是重新起的一个socket，和socket服务器并无关联，与服务器中的heart代码中的服务器相对应（如果加上监控socket的服务器，服务器项目中其实是有两个服务器的，一个作为socket服务器，一个作为监控socket的服务器），这样就可以避免一直重新new出socket造成的channel异常。

一开始我选择用过quartz定时器作为轮巡监测，也试着搭建过webservice，但是都失败了。quartz轮巡会造成socket服务器的阻塞，webservice的话，如果服务器done机，那么这个webservice也就跟着一起done掉了，更不要谈什么监测了，所以，创建一个单线程的监测，速度又快（2秒一次完全够了），又安全，何乐不为？

注意，客户端的config包中的xml配置文件其实是和服务器中的一模一样的，我是在监测服务器的项目中为了能够在服务器done机后重新启动服务器，在buildPath中加入了服务器的项目，但是服务器项目中需要引用EchoServer.xml这个文件，所以在客户端重新复制了一份。

以下是服务器端的监测线程：

package heart;

import java.io.ObjectInput;
import java.io.ObjectInputStream;
import java.net.ServerSocket;
import java.net.Socket;
import heart.Entity;

public class ServerHeart extends Thread {

    private ServerSocket server = null;
    Object obj = new Object();

    @Override
    public void run() {
        try {
            server = new ServerSocket(9090);

            while (true) {
                Socket client = server.accept();
                synchronized (obj) {
                    new Thread(new Client(client)).start();
                }
            }

        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    /**
     * 客户端线程
     *
     * @author USER
     *
     */
    class Client implements Runnable {
        Socket client;

        public Client(Socket client) {
            this.client = client;
        }

        @Override
        public void run() {
            try {
                while (true) {
                    ObjectInput in = new ObjectInputStream(client.getInputStream());
                    Entity entity = (Entity) in.readObject();
                    System.out.println(entity);
                }
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }

    /**
     * 程序的入口main方法
     *
     * @param args
     */
    public static void main(String[] args) {
        System.out.println("开始检测服务器是否done机...");
        new ServerHeart().start();
    }
}

下面附上两个项目的传送门：http://files.cnblogs.com/files/fengwenzhee/monitorSocket.rar

另外：SSsocket(服务器项目)中有一个Test.jar文件，这个可不是jar包，里面是socket服务器的测试原件，直接解压就可以用了。

如果要在linux系统测试，就把两个项目打成可执行的jar（runnable JAR file），然后导入linux虚拟机中（我是通过putty这个辅助软件导入的）地址：http://files.cnblogs.com/files/fengwenzhee/putty.rar，命令在我另一篇博客中有提到，然后jar -jar monitor.jar命令启动项目，（我是直接启动的监控项目，正好测试一下是否成功拉起done机的socket服务器）。

测试成功，至于服务器的socket我用的是quicksocket，关于服务器有什么不明白的可以直接留言。

转载请注明出处。