Java实现Linux下服务器程序的双守护进程

一、简介
  现在的服务器端程序很多都是基于Java开发,针对于Java开发的Socket程序,这样的服务器端上线后出现问题需要手动重启,万一大半夜的挂了,还是特别麻烦的。
  大多数的解决方法是使用其他进程来守护服务器程序,如果服务器程序挂了,通过守护进程来启动服务器程序。
  万一守护进程挂了呢?使用双守护来提高稳定性,守护A负责监控服务器程序与守护B,守护B负责监控守护A,任何一方出现问题,都能快速的启动程序,提高服务器程序的稳定性。

  Java的运行环境不同于C等语言开发的程序,Java程序跑在JVM上面。不同于C语言可以直接创建进程,Java创建一个进程等同于使用java -jar xxx.jar启动一个程序。
  Java启动程序并没有C#类似的单实例限制,你可以启动多个,但是你不能启动多个,不能让多个守护A去守护服务器程序,万一启动了多个服务器程序怎么办?

二、技术讲解
这里的技术讲解比较粗略,具体请百度一下,这里只讲解作用。
1、jps命令。
  JDK自带的命令工具,使用jps -l可以列出正在运行的Java程序,显示Java程序的pid与Name。只对Java程序有效,其实查看的是运行的JVM
2、java.nio.channels.FileLock类的使用
  这个是Java new IO中的类,使用他可以维持在读取文件的给文件加上锁,判断文件时候有锁可以判断该文件是否被其他的程序使用
3、ProcessBuilder与Process
  这两个原理差不多,都是调用系统的命令运行,然后返回信息。但是硬编码会导致你的Java程序失去可移植性,可以将命令独立到配置文件中。

三、设计原理
Server:服务器程序
A:守护进程A
B:守护进程B
A.lock:守护进程A的文件锁
B.lock:守护进程B的文件锁
----------------------------------------------------------------------------------
Step 1:首先不考虑Server,只考虑A与B之间的守护
1.A判断B是否存活,没有就启动B
2.B判断A是否存活,没有就启动A
3.在运行过程中A与B互相去拿对方的文件锁,如果拿到了,证明对面挂了,则启动对方。
4.A启动的时候,获取A.lock文件的锁,如果拿到了证明没有A启动,则A运行;如果没有拿到锁,证明A已经启动了,或者是B判断的时候拿到了锁,如果是A已经启动了,不需要再次启动A,如果是B判断的时候拿到了锁,没关紧  要,反正B会再次启动A。
5.B启动的时候原理与A一致。
6.运行中如果A挂了,B判断到A已经挂了,则启动A。B同理。

Step 2:加入Server
1.A用于守护B和Server,B用于守护A。
2.原理与Step 1 一致,只是A多个一个守护Serer的任务。
3.当A运行的时候,使用进程pid检测到Server已经挂了,就启动Server
4.如果Server与A都挂了,B会启动A,然后A启动Server
5.如果Server与B挂了,A启动Server与B
6.如果A与B都挂了,守护结束

Step 3:使用Shutdown结束守护,不然结束Server后会自动启动

四、实现
1、GuardA的实现

 1 public class GuardA {
 2     // GuardA用于维持自己的锁
 3     private File fileGuardA;
 4     private FileOutputStream fileOutputStreamGuardA;
 5     private FileChannel fileChannelGuardA;
 6     private FileLock fileLockGuardA;
 7     // GuardB用于检测B的锁
 8     private File fileGuardB;
 9     private FileOutputStream fileOutputStreamGuardB;
10     private FileChannel fileChannelGuardB;
11     private FileLock fileLockGuardB;
12
13     public GuardA() throws Exception {
14         fileGuardA = new File(Configure.GUARD_A_LOCK);
15         if (!fileGuardA.exists()) {
16             fileGuardA.createNewFile();
17         }
18         //获取文件锁,拿不到证明GuardA已启动则退出
19         fileOutputStreamGuardA = new FileOutputStream(fileGuardA);
20         fileChannelGuardA = fileOutputStreamGuardA.getChannel();
21         fileLockGuardA = fileChannelGuardA.tryLock();
22         if (fileLockGuardA == null) {
23             System.exit(0);
24         }
25
26         fileGuardB = new File(Configure.GUARD_B_LOCK);
27         if (!fileGuardB.exists()) {
28             fileGuardB.createNewFile();
29         }
30         fileOutputStreamGuardB = new FileOutputStream(fileGuardB);
31         fileChannelGuardB = fileOutputStreamGuardB.getChannel();
32     }
33
34     /**
35      * 检测B是否存在
36      *
37      * @return true B已经存在
38      */
39     public boolean checkGuardB() {
40         try {
41             fileLockGuardB = fileChannelGuardB.tryLock();
42             if (fileLockGuardB == null) {
43                 return true;
44             } else {
45                 fileLockGuardB.release();
46                 return false;
47             }
48         } catch (IOException e) {
49             System.exit(0);
50             // never touch
51             return true;
52         }
53     }
54 }

2、GuardServer的实现

 1 public class GuardServer {
 2     private String servername;
 3
 4     public GuardServer(String servername) {
 5         this.servername = servername;
 6     }
 7
 8     public void startServer(String cmd) throws Exception {
 9         System.out.println("Start Server : " + cmd);
10         //将命令分开
11 //        String[] cmds = cmd.split(" ");
12 //        ProcessBuilder builder = new ProcessBuilder(cmds);
13
14         //
15         ProcessBuilder builder=new ProcessBuilder(new String[]{"/bin/sh","-c",cmd});
16         //将服务器程序的输出定位到/dev/tty
17         builder.redirectOutput(new File("/dev/tty"));
18         builder.redirectError(new File("/dev/tty"));
19         builder.start(); // throws IOException
20         Thread.sleep(10000);
21     }
22
23     /**
24      * 检测服务是否存在
25      *
26      * @return 返回配置的java程序的pid
27      * @return pid >0 返回的是 pid <=0 代表指定java程序未运行
28      * **/
29     public int checkServer() throws Exception {
30         int pid = -1;
31         Process process = null;
32         BufferedReader reader = null;
33         process = Runtime.getRuntime().exec("jps -l");
34         reader = new BufferedReader(new InputStreamReader(process.getInputStream()));
35         String line;
36         while ((line = reader.readLine()) != null) {
37             String[] strings = line.split("\\s{1,}");
38             if (strings.length < 2)
39                 continue;
40             if (strings[1].contains(servername)) {
41                 pid = Integer.parseInt(strings[0]);
42                 break;
43             }
44         }
45         reader.close();
46         process.destroy();
47         return pid;
48     }
49 }

3、GuardAMain实现

 1 public class GuardAMain {
 2     public static void main(String[] args) throws Exception {
 3         GuardA guardA = new GuardA();
 4         Configure configure = new Configure();
 5         GuardServer server = new GuardServer(configure.getServername());
 6         while (true) {
 7             // 如果GuardB未运行 运行GuardB
 8             if (!guardA.checkGuardB()) {
 9                 System.out.println("Start GuardB.....");
10                 Runtime.getRuntime().exec(configure.getStartguardb());
11             }
12             // 检测服务器存活
13             if (server.checkServer() <= 0) {
14                 boolean isServerDown = true;
15                 // trip check
16                 for (int i = 0; i < 3; i++) {
17                     // 如果服务是存活着
18                     if (server.checkServer() > 0) {
19                         isServerDown = false;
20                         break;
21                     }
22                 }
23                 if (isServerDown)
24                     server.startServer(configure.getStartserver());
25             }
26             Thread.sleep(configure.getInterval());
27         }
28     }
29 }

4、Shutdown实现

 1 public class ShutDown {
 2     public static void main(String[] args) throws Exception {
 3         Configure configure = new Configure();
 4         System.out.println("Shutdown Guards..");
 5         for (int i = 0; i < 3; i++) {
 6             Process p = Runtime.getRuntime().exec("jps -l");
 7             BufferedReader reader = new BufferedReader(new InputStreamReader(p.getInputStream()));
 8             String line;
 9             while ((line = reader.readLine()) != null) {
10                 if (line.toLowerCase().contains("Guard".toLowerCase())) {
11                     String[] strings = line.split("\\s{1,}");
12                     int pid = Integer.parseInt(strings[0]);
13                     Runtime.getRuntime().exec(configure.getKillcmd() + " " + pid);
14                 }
15             }
16             p.waitFor();
17             reader.close();
18             p.destroy();
19             Thread.sleep(2000);
20         }
21         System.out.println("Guards is shutdown");
22     }
23 }

5、GuardB与GuardA类似

五、下载与使用

项目文件夹:guard_demo

下载地址:http://pan.baidu.com/s/1bn1Y6BX

如果有什么疑问或者建议,请联系我

时间: 2024-10-05 15:04:38

Java实现Linux下服务器程序的双守护进程的相关文章

linux下Shell编程--标准的守护进程的启动脚本

一个标准的守护进程的启动脚本: #! /bin/sh WHOAMI=`whoami` PID=`ps -u $WHOAMI | gerp mydaemond | awk '{print $1}'` if (test "$1" = "") then echo "mydaemond [start][stop][version]" exit 0 fi if ( test "$1" = "status") then

linux下服务器守护进程的安装

一.在服务器上安装rstatd守护进程安装步骤:1. 从网上下载rstatd2. 将该文件放到/home/user目录下3. chmod 777 rpc.rstatd----改变该文件读写的权限,拥有所有权限.4. chmod 777 configure ---同上5. ./configure ---配置6. make ---编译7. make install ---安装8. rpc.rstatd ---启动rstatd进程二.在lr中配置从LR里面add measurement, 填写linu

Linux下的程序包管理之源码形式

 Linux下程序包管理之源码形式 程序包的前世今生: 说到程序包管理,不得不提到是就是程序包是由什么组成的?也就是怎么形成的?程序是由源代码程序经过预处理.编译.然后汇编形成二进制的程序,这是针对特定硬件而形成的程序.有计算机编程基础的同学都应该知道源代码编译的时候是要调用特定的库(库文件),而这些库,在不同的系统上是不同的,比如Linux和window上的就不同,不同发行版的Linux上的库也不尽相同,所以这就导致了在不同种类系统上编译生成的二进制程序的运行环境也不尽相同,那么这些程序是不能

windows下QT前台和linux下后台程序通过socket通信

通常情况下,linux下的后台程序不需要GUI进行展示,而前台程序往往有个界面,方便和用户的交互.本文所演示的例 子,是QT 程序和后台linux进程(C语言)交互,通过socket传输的内容是结构体.因为QT本身是跨平台的框架,因此以后前端程序移植到其它平台依然能很好 的运行. 结构体的定义如下: struct Test              {                      int a;                      char b;              };

Linux下C程序的链接过程

今天看到一个很有意思的小程序,它让我对Linux下C程序的编译链接有了一个全新的认识! 这个程序的就是写一个简单的输出"hello World!":   要求:1.不使用C运行库,写一个独立于任何库的程序.(也就是说我们不能#include<stdio>).       2.不适用main函数为程序的入口(大家都知道一般使用了库的程序都是使用main函数作为程序的入口,在这里我们使用自己写的函数nomain作为程序的入口).       3.使用连接器ld把程序的所有段合为

Linux下c++程序内存泄漏检测代码范例

Linux下对于程序内存泄漏检测的方法很多,最常用的的莫过于使用valgrind工具.但是valgrind相当于让程序在虚拟机中运行,会带来较大的系统资源开销,还会对程序的运行效率产生较大影响,对于那种资源占用大的程序,如果需要长时间运行才能暴露的泄漏问题,它就显得不太好用. linux下的c++程序中自己实现一个轻量级的泄漏检测代码其实是比较方便的,下面我就给出一个简单的范例,并作简单的说明.当然,我们还是应该提倡使用共享指针,用共享指针自动管理内存可以避免内存泄漏这样的不必要的麻烦. 基本原

【Java】Linux下安装配置Oracle JDK 1.7版本

1 环境 Vmware虚拟机中的Ubuntu 12.04 32位系统 2具体安装步骤 ①下载最新的jdk包 注意jdk区分32位版本和64位版本,要与Ubuntu兼容才行 下载地址 http://www.oracle.com/technetwork/java/javase/downloads/jdk7-downloads-1880260.html ②创建一个目录,解压压缩包 mkdir usr/lib/jvm 移动到该目录,并解压 [email protected]:/usr/lib$ sudo

linux下多进程的文件拷贝与进程相关的一些基础知识

之前实现了用文件IO的方式可以实现文件的拷贝,那么对于进程而言,我们是否也可以实现呢? 答案是肯定的. 进程资源: 首先我们先回顾一下,进程的运行需要哪些资源呢?其资源包括CPU资源,内存资源,当然还有时间片资源,我们都知道进程是有 栈, 堆,  只读数据段,  数据段(已初始化的全局变量静态变量),bss段(未初始化的),   代码段还有一组寄存器值. 进程命令: 另外我们也可以通过 ps  -ef |grep 进程名命令来查看进程号(PID)和父进程号(PPID),之后还可以通过 ps au

Linux下查看端口,强制kill进程

1.查看8088端口被哪个进程占用:netstat -apn | grep 8088 2.强制kill某一进程:kill -s 9 1827 Linux下查看端口,强制kill进程