精华内容
下载资源
问答
  • tomcat宕机重启脚本

    2015-03-14 11:58:34
    tomcat宕机重启脚本,比较简单的一种设置
  • tomcat宕机自动重启

    千次阅读 2018-02-12 11:06:53
    不多说了 直接上代码 有问题的 欢迎评论交流package com.pzx.tomcat;import java.io.BufferedReader;import java.io.IOException;import java.io.InputStream;import java.io.InputStreamReader;import java.net....

    不多说了 直接上代码  有问题的   欢迎评论交流

    package com.pzx.tomcat;

    import java.io.BufferedReader;
    import java.io.IOException;
    import java.io.InputStream;
    import java.io.InputStreamReader;
    import java.net.MalformedURLException;
    import java.net.URL;
    import java.net.URLConnection;
    import java.util.Date;
    import java.util.Properties;

    import org.slf4j.Logger;
    import org.slf4j.LoggerFactory;


    /**
     * @describe:TomcatMonitor.java
     *
     * @date 2018/02/01
     * @author pzx
     */
    public class TomcatMonitor implements Runnable {

     
    // private static final Logger logger = LoggerFactory.getLogger(TomcatMonitor.class.getName());
     
     String start = ""; // 系统命令 启动
     String stop = ""; // 系统命令 关闭
     String killJava = ""; // 强制关闭java的命令
     String testHttp = ""; // 测试连接地址
     int testIntervalTime = 1;// 测试连接间隔时间,单位为秒
     int waitIntervalTime = 2; // 等待测试间隔时间,单位为秒
     int testTotalCount = 5; // 测试连接总次数

     Thread thread = null;

     public TomcatMonitor() {
      InputStream in = TomcatMonitor.class.getResourceAsStream("config.properties");
      Properties p = new Properties();
      try {
       p.load(in);
       stop = p.getProperty("stop");
       start = p.getProperty("start");
       killJava=p.getProperty("killJava");
       testHttp = p.getProperty("testHttp");
       testIntervalTime = Integer.parseInt(p.getProperty("testIntervalTime"));
       waitIntervalTime = Integer.parseInt(p.getProperty("waitIntervalTime"));
       testTotalCount = Integer.parseInt(p.getProperty("testTotalCount"));
      } catch (Exception e) {
       e.printStackTrace();
      }

      System.out.println("*******************初始化成功!*******************");

      thread = new Thread(this);
      thread.start();
     }

     public void run() {
      System.out.println("正在监控中...");
    //   logger.debug("正在监控中...");
      int testCount = 0;
      while (true) {
       testCount = 0;
       testCount++;
       boolean isrun = test();
       System.out.println("正在启动测试连接,尝试连接次数为:" + testCount + ",结果为:" + (isrun == false ? "失败." : "成功!")+"监控时间为:"+new Date());
       while (!isrun) {
        if (testCount >= testTotalCount)
         break;
        try {
         thread.sleep(testIntervalTime * 1000);
        } catch (InterruptedException e) {
         e.printStackTrace();
        }
        testCount++;
        System.out.println("正在启动测试连接,尝试连接次数为:" + testCount + ",结果为:" + (isrun == false ? "失败." : "成功!")+"监控时间为:"+new Date());
        isrun = test();
       }

       if (!isrun) {
        try {
         System.out.println("测试连接失败,正在重启tomcat");
         System.out.println("开始停止tomcat");
         // 关闭tomcat服务
         Process proc = Runtime.getRuntime().exec(stop);
    //     // 关闭后线程沉睡
         thread.sleep(20000);
         //强制关闭java.exe(正式环境关闭tomcat很长时间黑窗口才关闭 强制杀掉)
         try {
          System.out.println("开始强制杀进程java.exe");
          Process procJava = Runtime.getRuntime().exec(killJava);
           //强制杀线程后沉睡
          thread.sleep(5000);
         } catch (Exception e) {
          //强制杀线程有异常不处理
          System.out.println("强制杀进程java.exe异常");
         }
         System.out.println("开始启动tomcat");
         // 启动tomcat服务
         Process p = Runtime.getRuntime().exec(start);
         System.out.println("重启tomcat成功");
         thread.sleep(30000);
         //杀掉每次执行命令的黑窗口,默认是不关掉的 不杀的话 会开无限个cmd窗口
         killProcess();
        } catch (Exception e) {
         e.printStackTrace();
         System.out.println("重启tomcat异常,请查看先关错误信息。。。。。");
        }
       }

       try {
        thread.sleep(waitIntervalTime * 1000);
       } catch (InterruptedException e) {
        e.printStackTrace();
       }

       isrun = test();
      }
     }

     public boolean test() {

      URL url = null;
      try {
       url = new URL(testHttp);
      } catch (MalformedURLException e) {
       e.printStackTrace();
      }
      try {
       URLConnection urlConn = url.openConnection();
       urlConn.setReadTimeout(10000);
       BufferedReader reader = new BufferedReader(new InputStreamReader(urlConn.getInputStream())); // 实例化输入流,并获取网页代码
       String s;
       while ((s = reader.readLine()) != null) {
        return true;
       }
      } catch (Exception e) {
       return false;
      }
      return false;
     }

     public static void main(String[] args) throws Exception {
      TomcatMonitor tm = new TomcatMonitor();
     }

     //关闭cmd窗口
     public static void killProcess() {
      Runtime rt = Runtime.getRuntime();
      Process p = null;
      try {
       rt.exec("cmd.exe /C start wmic process where name='cmd.exe' call terminate");
      } catch (IOException e) {
       e.printStackTrace();
      }
     }

    }

    配置文件如下:

    #系统命令 启动   
    start=cmd /c start D:\\tomcat-standard\\bin\\startup.bat
    #start=cmd /c start D:\\mh_qianyi\\tomcat8-minhang\\tomcat8-minhang\\bin\\startup.bat
     
    #关闭 
    #stop=cmd /c start D:\\mh_qianyi\\tomcat8-minhang\\tomcat8-minhang\\bin\\shutdown.bat
    stop=cmd /c start D:\\tomcat-standard\\bin\\shutdown.bat

    #强制关闭java的命令
    killJava=cmd /c start taskkill /f /t /IM java.exe2
     
    #测试连接总次数 
    testTotalCount=2
     
    #连接失败时,再次检测时间间隔,单位为秒
    testIntervalTime=5
     
    #连接超时时间,即多少秒tomcat没响应视为宕机,单位为秒 
    connectionTimeout=15
     
    #tomcat启动时间,防止在tomcat尚未启动完成的时候,程序又去检验tomcat状态,造成尚未启动完成又重新启动,单位为秒 
    tomcatStartTime=600
     
    #测试连接地址 
    testHttp=http://localhost/mhmscp/login.jsp
     
    #正常情况下,每次检测间隔时间,单位为秒 
    waitIntervalTime=120

    
    展开全文
  • 在项目后期维护中会遇到这样的情况,tomcat在内存溢出的时候就出现死机的情况和遇到长时间不响应,需要人工手动关闭和重启服务,针对这样的突发情况,希望程序能自动处理问题而不需要人工关于,所以才有了目前的需求...

    转载至:

    在项目后期维护中会遇到这样的情况,tomcat在内存溢出的时候就出现死机的情况和遇到长时间不响应,需要人工手动关闭和重启服务,针对这样的突发情况,希望程序能自动处理问题而不需要人工关于,所以才有了目前的需求。

    一、设置tomcat定时启动

    1,首先将tomcat注册为服务,先打开tomcat的bin目录下service.bat文件,修改下面的值,这是sevvice的注册名称和显示名称,一般可使用默认值。

    set SERVICE_NAME=Tomcat7 set PR_DISPLAYNAME=Apache Tomcat

    【然后修改jvm大小,搜索到--JvmMs 128 --JvmMx 256 进行修改,因为做成服务启动,启动的时候就不会用到 catalina.bat,也就不会读取里面的jvm设置了。】(可选,可以不设置)

    然后运行cmd命令窗口,cd 到tomcat的bin目录下,运行下面的命令 service.bat install 运行成功过后,会提示服务已经安装成功。

    2,制作重启脚本restart.bat,文件内容如下 net stop Tomcat7 net start Tomcat7

    3,利用控制面板里面的“任务计划”设置第2步的脚本运行时间计划

    4,如果想删除服务,也很简单,先把服务停掉,然后在cmd窗口运行下面的命令即可,后面那个Tomcat7是服务名。 sc delete Tomcat7

    需要注意的是,需要先把服务停掉,才能一次删除成功,或者删除之后再停止服务,就会发现服务已经删除成功了。

    二、监听tomcat

     只要运行start.bat即可,相关配置在config.properties文件中,默认即可, 如果服务名不对应就修改关闭和启动命令的服务名即可:net start 【Tomcat7】括号中服务名,然后运行start.bat

    下面是具体的监听代码:

    首先是监听类TomcatMonitor .Java

    [java]  view plain  copy
      在CODE上查看代码片 派生到我的代码片
    1. import java.io.BufferedReader;  
    2. import java.io.IOException;  
    3. import java.io.InputStream;  
    4. import java.io.InputStreamReader;  
    5. import java.net.MalformedURLException;  
    6. import java.net.URL;  
    7. import java.net.URLConnection;  
    8. import java.util.Properties;  
    9. /** 
    10.  * @describe:TomcatMonitor.java 
    11.  *  
    12.  * @date 2016-7-4 
    13.  * @author liuweilong 
    14.  */  
    15. public class TomcatMonitor implements Runnable{  
    16.       
    17.     String start=""//系统命令 启动  
    18.     String stop=""//系统命令 关闭  
    19.     String testHttp="";  //测试连接地址  
    20.     int testIntervalTime=1;//测试连接间隔时间,单位为秒  
    21.     int waitIntervalTime=2//等待测试间隔时间,单位为秒  
    22.     int testTotalCount=5//测试连接总次数  
    23.       
    24.     Thread thread=null;  
    25.       
    26.     public TomcatMonitor(){  
    27.         InputStream in = TomcatMonitor.class.getResourceAsStream("config.properties");  
    28.         Properties p = new Properties();  
    29.          try {  
    30.             p.load(in);  
    31.             stop=p.getProperty("stop");  
    32.             start=p.getProperty("start");  
    33.             testHttp=p.getProperty("testHttp");  
    34.             testIntervalTime=Integer.parseInt(p.getProperty("testIntervalTime"));  
    35.             waitIntervalTime=Integer.parseInt(p.getProperty("waitIntervalTime"));  
    36.             testTotalCount=Integer.parseInt(p.getProperty("testTotalCount"));             
    37.         } catch (Exception e) {  
    38.                     e.printStackTrace();  
    39.         }  
    40.               
    41.         System.out.println("*******************初始化成功!*******************");  
    42.            
    43.           
    44.         thread=new Thread(this);  
    45.         thread.start();       
    46.     }  
    47.       
    48.     public void run() {  
    49.         System.out.println("正在监控中...");     
    50.         int testCount=0;  
    51.         while(true){  
    52.             testCount=0;  
    53.             testCount++;              
    54.             boolean isrun=test();  
    55.             System.out.println("正在启动测试连接,尝试连接次数为:"+testCount+",结果为:"+(isrun==false?"失败.":"成功!"));                 
    56.             while(!isrun){  
    57.                 if(testCount>=testTotalCount)break;  
    58.                 try {  
    59.                     thread.sleep(testIntervalTime*1000);  
    60.                 } catch (InterruptedException e) {  
    61.                     e.printStackTrace();  
    62.                 }  
    63.                 testCount++;  
    64.                 System.out.println("正在启动测试连接,尝试连接次数为:"+testCount+",结果为:"+(isrun==false?"失败.":"成功!"));                 
    65.                 isrun=test();  
    66.             }  
    67.               
    68.             if(!isrun){               
    69.                 try{        
    70.                     //关闭tomcat服务      
    71.                     Process proc = Runtime.getRuntime().exec(stop);  
    72.                     thread.sleep(5000);  
    73.                     //启动tomcat服务  
    74.                     System.out.println("测试连接失败,正在重启tomcat");  
    75.                     Process p=Runtime.getRuntime().exec(start);   
    76.                     System.out.println("重启tomcat成功");  
    77.                 }catch(Exception e){  
    78.                     e.printStackTrace();  
    79.                     System.out.println("重启tomcat异常,请查看先关错误信息。。。。。");  
    80.                       
    81.                 }                 
    82.             }  
    83.               
    84.             try {  
    85.                 thread.sleep(waitIntervalTime*1000);  
    86.             } catch (InterruptedException e) {  
    87.                 e.printStackTrace();  
    88.             }  
    89.               
    90.             isrun=test();  
    91.         }         
    92.     }  
    93.       
    94.     public boolean test(){  
    95.           
    96.         URL url=null;         
    97.         try {  
    98.             url = new URL(testHttp);  
    99.         } catch (MalformedURLException e) {  
    100.             e.printStackTrace();  
    101.         }  
    102.         try {  
    103.             URLConnection urlConn=url.openConnection();  
    104.             urlConn.setReadTimeout(15000);  
    105.             BufferedReader reader = new BufferedReader(new InputStreamReader( urlConn.getInputStream()));            //实例化输入流,并获取网页代码  
    106.                    String s;                                         
    107.                    while ((s = reader.readLine()) != null) {  
    108.                       return true;     
    109.                    }                          
    110.         } catch (Exception e) {  
    111.           return false;  
    112.         }  
    113.         return false;  
    114.     }  
    115.       
    116.       
    117.     public static void main(String[] args) throws Exception{  
    118.         TomcatMonitor tm=new TomcatMonitor();  
    119.     }  
    120.       
    121.   
    122. }  

    然后是对应的配置文件config.properties:

    [plain]  view plain  copy
      在CODE上查看代码片 派生到我的代码片
    1. #系统命令 启动  
    2. start=net start Tomcat7  
    3.   
    4. #关闭  
    5. stop = net stop Tomcat7  
    6.   
    7. #测试连接总次数  
    8. testTotalCount=3  
    9.   
    10. #连接失败时,再次检测时间间隔,单位为秒  
    11. testIntervalTime=3  
    12.   
    13. #连接超时时间,即多少秒tomcat没响应视为宕机,单位为秒  
    14. connectionTimeout=15  
    15.   
    16. #tomcat启动时间,防止在tomcat尚未启动完成的时候,程序又去检验tomcat状态,造成尚未启动完成又重新启动,单位为秒  
    17. tomcatStartTime=600  
    18.   
    19. #测试连接地址  
    20. testHttp=http://127.0.0.1:8080  
    21.   
    22. #正常情况下,每次检测间隔时间,单位为秒  
    23. waitIntervalTime=30  

    最后是启动的start.bat:

    [plain]  view plain  copy
      在CODE上查看代码片 派生到我的代码片
    1. java -cp . TomcatMonitor  
    展开全文
  • Linux下自动检测Tomcat是否宕机,并自动重启 公司服务器tomcat经常自动挂掉,具体原因无法找到。所以做了这次调整。让Linux自动检测tomcat是否宕机 1. 新建一个名字为XX.sh的文件,文件内容如下 #!/bin/sh # 获取...

    Linux下自动检测Tomcat是否宕机,并自动重启

    公司服务器tomcat经常自动挂掉,具体原因无法找到。所以做了这次调整。让Linux自动检测tomcat是否宕机

    1. 新建一个名字为XX.sh的文件,文件内容如下

    #!/bin/sh
    # 获取tomcat进程ID  /usr/local/tomcat_ds_api
    #TomcatID=$(ps -ef |grep tomcat |grep -w 'ps -ef |grep tomcat8.5'|grep -v 'grep'|awk '{print $2}')  
    # tomcat启动程序(这里注意tomcat实际安装的路径)  
    . /etc/profile #此行必不可少,若少了,tomcat无法自动重启
    StartTomcat=/root/apache-tomcat-8.5.40/bin/startup.sh #tomcat绝对路径的启动文件地址
    StopTomcat=/root/apache-tomcat-8.5.40/bin/shutdown.sh  #tomcat绝对路径的关闭文件地址
    # 定义要监控的页面地址  
    WebUrl=“你代码中的某个映射地址,我填的是登录地址”
    # 日志输出 
    TomcatMonitorLog=/tmp/TomcatMonitor.log  
    JAVA_HOME=/usr/local/software/jdk1.8.0_131#下面两行可以不要
    JRE_HOME=/usr/local/software/jdk1.8.0_131/jre
    tomcat_path='/root/apache-tomcat-8.5.40' #tomcat 完整路径
    
    #获取 tomcat_path 所知tomcat 的进程ID
    TomcatID=$(ps -ef |grep tomcat |grep -w $tomcat_path|grep -v 'grep'|awk '{print $2}')
    Monitor() 
    {  
      echo "[info]开始监控tomcat...[$(date +'%F %H:%M:%S')]"  
      if [[ $TomcatID ]];then # 这里判断TOMCAT进程是否存在  
        echo "[info]当前tomcat进程ID为:$TomcatID,继续检测页面..."  
        # 检测是否启动成功(成功的话页面会返回状态"200")  
        TomcatServiceCode=$(curl -I -m 10 -o /dev/null -s -w %{http_code} $WebUrl )  
    if [ $TomcatServiceCode -eq 200 ];then  
            echo "[info]页面返回码为$TomcatServiceCode,tomcat启动成功,测试页面正常......"  
        else  
            echo "[error]tomcat页面出错,请注意......状态码为$TomcatServiceCode,错误日志已输出到$GetPageInfo"  
            echo "[error]页面访问出错,开始重启tomcat"  
            #kill -9 $TomcatID  # 杀掉原tomcat进程  
            #sleep 3  
            rm -rf $TomcatCache # 清理tomcat缓存  
    		$StopTomcat
    		echo "[info] tomcat关闭成功"
            $StartTomcat  
    		echo "[info] tomcat重启成功"
        fi  
      else  
        echo "[error]tomcat进程不存在!tomcat开始自动重启..."  
        echo "[info]$StartTomcat,请稍候......"  
        #rm -rf $TomcatCache  
        $StartTomcat  
      fi  
      echo "------------------------------"  
    }  
    Monitor>>$TomcatMonitorLog
    

    2.将文件复制到linux的某个文件夹下(我是直接放在tomcat的bin目录下的)

    此时,这个脚本文件是不可用的

    执行: vi filename
    输入: :set ff=unix
    			:wq
    			回车保存
    

    3.执行该文件

    ./**.sh
    到这里脚本文件就写完了,童鞋们可以去查看日志了。
    这里是我们手动启动的,接下来,我们就要去配置一个自动定时任务啦

    4.安装crontab

    yum install vixie-cron
    

    安装完成。查看一下常用命令。

    /sbin/service crond start //启动服务
    /sbin/service crond stop //关闭服务
    /sbin/service crond restart //重启服务
    /sbin/service crond reload //重新载入配置
    查看crontab服务状态:service crond status
    手动启动crontab服务:service crond start
    查看crontab服务是否已设置为开机启动,执行命令:ntsysv
    在CentOS系统中加入开机自动启动:chkconfig --level 35 crond on
    

    5.添加定时任务

     crontab  -e --编辑服务文件,添加定时任务
     */1 * * * * 文件所在位置/**.sh
     :wq 保存
    

    启动crontab,这样就完成了。
    脚本文件的日志地址在:/tmp 下,可以自行查看

    展开全文
  • 1.在服务器上创建tomcatMonitor.sh 2.使文件生效chmod u+x *.sh 3.编辑tomcatMonitor.sh文件,if及fi必须成对出现,如果if then写在一行需要用;隔开 #!/bin/sh # 获取tomcat的PID TOMCAT_PID=$(ps -ef | grep ...

    1.在服务器上创建tomcatMonitor.sh

    2.使服务器.sh文件生效chmod u+x *.sh

    3.编辑tomcatMonitor.sh文件,if及fi必须成对出现,如果if then写在一行需要用;隔开

    #!/bin/sh
    # 获取tomcat的PID
    TOMCAT_PID=$(ps -ef | grep tomcat | grep -v 'tomcatMonitor'  |grep -v 'grep' | awk '{print $2}')
    # tomcat的启动文件位置
    START_TOMCAT=/usr/local/tomcat6/bin/startup.sh
    # 需要监测的一个GET请求地址
    MONITOR_URL=http://localhost:8080/hnrwms/login.do?method=begin
    # 监测日志输出路径
    TOMCAT_MONITOR_LOG=/home/user/tomcatMonitor.log
    Monitor()
    {
      # 输出时间,注意date后有个空格
      echo "[$(date +'%F %H:%M:%S')]"
      echo "[info]$TOMCAT_PID,开始监控tomcat..."
      # 判断tomcat的PID是否存在,如不存在说明tomcat进程已关闭,注意[]前后,变量前后,都要有空格
      if [[ $TOMCAT_PID ]];then
        echo "[info]当前tomcat的PID为:$TOMCAT_PID,继续监测页面..."
        # 向监测的地址发送请求并获取响应码
        HTTP_REPONSE_STATUS=$(curl -l -m 10 -o /dev/null -s -w %{http_code} $MONITOR_URL)
        # 如果响应码为200证明tomcat在正常启用
        if [[ $HTTP_REPONSE_STATUS -eq 200 ]];then
          echo "[info]tomcat启动正常..."
        else
          echo "[error]页面返回码为$HTTP_REPONSE_STATUS,开始重启tomcat..."
          # 结束tomcat进程
          kill -9 $TOMCAT_PID
          # 5秒后重启tomcat
          sleep 5
          $START_TOMCAT
        fi
      else
        echo "[error]tomcat进程不存在,开始启动..."
        echo "[info]$START_TOMCAT,..."
        $START_TOMCAT
      fi
      echo "监测执行完成"
    }
    # 输出到指定文件中
    Monitor>>$TOMCAT_MONITOR_LOG

    4.编辑定时器

    crontab -e

    5.编辑定时器文件,设置每分钟执行一次,加入如下代码并保存

    */1 * * * * /home/user/tomcatMonitor.sh

    6.重新加载定时器

    systemctl reload crond.service

    或者

     

    service crond reload


    7.输入如下代码可以看到tomcatManitor.sh已经在正常工作,如果log日志有多个tomcat进程应想办法过滤掉,不然会影响tomcat关掉进程和重启

    tail tomcatMonitor.log

    8.日志记录

    展开全文
  • Tomcat服务器的监听及宕机自动重启的开发   思路: 1、 通过http访问获取tomcat服务器上的项目访问状态200为正常 2、 当服务器宕机时,会进入异常IOException中,此时通过java调用tomcat的shutdown服务和startup...
  • 主要介绍了JAVA实现监测tomcat是否宕机及控制重启的方法,可实现有效的检测及控制tomcat服务器运行,具有一定参考借鉴价值,需要的朋友可以参考下
  • String dataStr = "admin 服务宕机 现已自动重启 请及时查看日志 修改错误!"; String[] emailStrs = emails.split(","); for (String email : emailStrs) { sendMail.sendMsg(email, dataStr); } } catch ...
  • 在项目后期维护中会遇到这样的情况,tomcat在内存溢出的时候就出现死机的情况和遇到长时间不响应,需要人工手动关闭和重启服务,针对这样的突发情况,希望程序能自动处理问题而不需要人工关于,所以才有了目前的需求...
  • tomcat异常关闭自动重启批处理脚本 word文档说明
  • 脚本中StartTomcatTomcatID,根据自己tomcat位置及tomcat名自定义 ,WebUrl可以是一个比较小的页面,也可以是服务器的资源图片 2.window上编辑后的sh脚本在linux执行报错 原因:window上保存文件,换行是\r\n ,...
  • 在项目后期维护中会遇到这样的情况,tomcat在内存溢出的时候就出现死机的情况和遇到长时间不响应,需要人工手动关闭和重启服务,针对这样的突发情况,希望程序能自动处理问题而不需要人工关于,所以才有了目前的需求...
  • 原文链接https://www.jggbk.com/blogs/article/17.html
  • Linux shell自动监控tomcat宕机重启

    千次阅读 2016-07-26 16:50:48
    参考网上例子 整了个 linux 的自动检测tomcat宕机的shell脚本 以后就可以自己重启了 出了问题。。(有时间放到linux定时任务计划里面)\ 下面检测的是一个工程里面的图片 来检测tomcat 是否正常 echo 001 这种打断...
  • # func:自动监控tomcat脚本并且执行重启操作 # 获取tomcat进程ID(其中[grep -w 'tomcat']代码中的tomcat需要替换为你的tomcat文件夹名) TomcatID=$(ps -ef |grep tomcat |grep -w 'apache-tomcat-7.0.96'|grep -v ...
  • 第一步crontab 安装及基本命令了解 ...安装成功, 看一下常用命令/sbin/service crond start //启动服务/sbin/service crond stop //关闭服务/sbin/service crond restart //重启服务/sbin/service crond r...
  • 采用cron执行任务机制实现自动重启。步骤如下: 1.编写shell脚本检查tomcat所用端口是否启用: <!-- lang: shell --> #!/bin/bash TOMCATPATH=/home/tomcat/apache-tomcat-7.0.33/ pt=`lsof -i :8080|grep -v ...
  • tomcat挂掉后自动重启脚本

    千次阅读 2017-09-25 16:03:44
    PROG_NAME=tomcat PROG_PATH=$(pwd) PROG_START=startup.sh # kill program if exist #force shutdown tomcat,copy this sh file to tomcat/bin dir echo "exec ./shutdown.sh" $PROG_PATH/shutdown.sh s
  • 将此下面的代码保存到一个.txt文件中,然后将后缀名命名为.vbs,再然后双击运行即可。 注意要修改的地方: 1.检查tomcat是否挂掉的访问路径,即下面代码中的:...D:\Program Files\apache-tomcat-9.0....
  • windows下 tomcat挂掉自动启动tomcat

    千次阅读 2018-04-17 16:38:52
    有时候tomcat会因为某些因素会自动挂掉,因此需要脚本来监测和自动启动脚本下面是的脚本。@echo off &amp;&amp; color 02 &amp;&amp; title EAM90 服务器自动连接 rem 查找是否存在java.exe这个...
  • Tomcat宕机检测以及宕机自启方法

    千次阅读 2019-03-19 10:56:33
    【颜色说明:橙色 为 命令 绿色 为 代码 】 一. 首先在本地创建一个monitorTomcat .sh的脚本文件,写下以下脚本 ...TomcatID=$(ps -ef |grep tomcat |grep -w 'tomcat'|grep -v 'grep'|awk '{print $2}') ...
  • # 使用while循环没10秒监督循环一次,检测tomcat进程是否存在,不存在的话启动tomcat while true do # 使用jps查看java进程 jps > ps.txt sleep 2 # 使用通道将java进程信息写入ps.txt文本中,之后检索是否存在...
  • 在项目后期维护中会遇到这样的情况,tomcat在内存溢出的时候就出现死机的情况和遇到长时间不响应,需要人工手动关闭和重启服务,针对这样的突发情况,希望程序能自动处理问题而不需要人工关于,所以才有了目前的需求...
  • 参考网上程序做的一个防止Tomcat服务器死掉重启的程序,界面是用swing画的,有配置、日志、以及重启等功能。。。 要求: 1.tomcat必须能通过startup.bat启动,且名称为tomcat7.exe(注册成服务就好了) 2.必须自带...
  • 1.在某个文件夹下创建脚本文件:touch tomcat-mobile.sh; 2.对该脚本赋予执行权限:chmod +x tomcat-mobile.sh; 3.编辑该脚本,vim tomcat-mobile.sh; TomcatID=$(ps -ef |grep tomcat |grep 8080 |grep -w '...
  • 写一个monitor.sh脚本用于判断tomcat进程是否存在,若不存在则启动tomcat 脚本链接https://download.csdn.net/download/qq_41959871/13722321 查看定时任务状态systemctl status crond /sbin/service crond start /...
  • 一开始没太注意这个问题,每当服务器挂了之后就手动重启,直到昨天有事没在电脑旁,服务器又宕机了,结果负责前端开发的同学只能等到昨晚我回去时重启服务器才能继续工作。这也让我意识到是时候该解决这个问题了。 ...
  • linux tomcat挂了自动重启

    千次阅读 2015-10-09 08:58:17
    tomcat同级,需要启动的需要包含”tomcat”字符 #!/bin/sh #获取目录 basePath=$(cd $(dirname $0);pwd) #查找此目录所有带tomcat的文件夹 echo "" echo "####################begin check####################" ...
  • #!/bin/bash ... #执行命令,重启tomcat tomcat_home=/usr/local/tomcat #停止tomcat变量 SHUTDOWN=$tomcat_home/bin/shutdown.sh #启动tomcat变量 STARTTOMCAT=$tomcat_home/bin/startup.sh ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 4,818
精华内容 1,927
关键字:

tomcat宕机自动重启