面对一些关于在Ubuntu 10.04上启动和关闭tomcat的问题

我面临着一些关于tomcat启动和关闭的问题。面对一些关于在Ubuntu 10.04上启动和关闭tomcat的问题

我使用

Tomcat的v.6.0.32（使用提取的Apache的网站下载的包，而不是一个被Ubuntu 10.04分布式）
Ubuntu的v.10.04

我使用命令启动tomcat：

$./catalina.sh jpda start

然后我试着用命令停止它：

$./catalina.sh stop

，并得到以下信息：

SEVERE: Catalina.stop: 
java.net.ConnectException: Connection refused 
    at java.net.PlainSocketImpl.socketConnect(Native Method) 
    at java.net.PlainSocketImpl.doConnect(PlainSocketImpl.java:351) 
    at java.net.PlainSocketImpl.connectToAddress(PlainSocketImpl.java:213) 
    at java.net.PlainSocketImpl.connect(PlainSocketImpl.java:200) 
    at java.net.SocksSocketImpl.connect(SocksSocketImpl.java:366) 
    at java.net.Socket.connect(Socket.java:529) 
    at java.net.Socket.connect(Socket.java:478) 
    at java.net.Socket.<init>(Socket.java:375) 
    at java.net.Socket.<init>(Socket.java:189) 
    at org.apache.catalina.startup.Catalina.stopServer(Catalina.java:422) 
    at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method) 
    at sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:39) 
    at sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:25) 
    at java.lang.reflect.Method.invoke(Method.java:597) 
    at org.apache.catalina.startup.Bootstrap.stopServer(Bootstrap.java:338) 
    at org.apache.catalina.startup.Bootstrap.main(Bootstrap.java:416)

我也尝试使用命令停止它：

$./catalina.sh stop -force

，但我得到的消息：

Kill failed: $CATALINA_PID not set

然后我再次尝试开始使用tomcat命令：

$./catalina.sh jpda start

在/ logs文件夹仅与以下错误消息生成catalina.out中：

ERROR: transport error 202: bind failed: Address already in use 
ERROR: JDWP Transport dt_socket failed to initialize, TRANSPORT_INIT(510) 
JDWP exit error AGENT_ERROR_TRANSPORT_INIT(197): No transports initialized [../../../src/share/back/debugInit.c:690] 
FATAL ERROR in native method: JDWP No transports initialized, jvmtiError=AGENT_ERROR_TRANSPORT_INIT(197)

如在错误指示“地址已在使用”我验证没有其他应用程序配置为在端口8080上运行。每当我终止进程ID并重新启动它时，启动工作正常。 当我需要停止tomcat服务器时，这需要我使用“KILL”命令手动终止进程。 我在其他机器上也遇到了与上面提到的环境相同的行为。

任何人都可以请让我知道是什么导致这种情况，以及如何解决这个问题？

感谢，
Jignesh

来源

2011-10-25 Jiggneshh Gohel

这不是刚下来的事实，无论是启动和关闭脚本共享相同的catalina.sh jvm属性，并且该端口已被启动脚本使用？ – Ellis

修正了Tomcat关闭这里issue.Posting的解决方案以供参考。

执行以下操作来解决它你的机器上：

1) Replace $CATALINA_HOME/bin/catalina.sh with catalina.sh shown below. 
2) Open /etc/bash.bashrc for edit 
3) Add following into it, (AFTER export CATALINA_HOME) 
      export CATALINA_PID="$CATALINA_HOME/catalina_pid.txt", 

      where $CATALINA_HOME is the tomcat home path 

4) Execute following : 
     $ source /etc/bash.bashrc 

5) Start tomcat: $CATALINA_HOME/bin/catalina.sh start (or catalina.sh jpda start) 

6) Shutdown tomcat using following command only for proper shutdown: 
     $CATALINA_HOME/bin/catalina.sh stop -force

catalina.sh - 包含我的在线评论

 #!/bin/sh 

     # Licensed to the Apache Software Foundation (ASF) under one or more 
     # contributor license agreements. See the NOTICE file distributed with 
     # this work for additional information regarding copyright ownership. 
     # The ASF licenses this file to You under the Apache License, Version 2.0 
     # (the "License"); you may not use this file except in compliance with 
     # the License. You may obtain a copy of the License at 
     # 
     #  http://www.apache.org/licenses/LICENSE-2.0 
     # 
     # Unless required by applicable law or agreed to in writing, software 
     # distributed under the License is distributed on an "AS IS" BASIS, 
     # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 
     # See the License for the specific language governing permissions and 
     # limitations under the License. 

     # ----------------------------------------------------------------------------- 
     # Start/Stop Script for the CATALINA Server 
     # 
     # Environment Variable Prerequisites 
     # 
     # CATALINA_HOME May point at your Catalina "build" directory. 
     # 
     # CATALINA_BASE (Optional) Base directory for resolving dynamic portions 
     #     of a Catalina installation. If not present, resolves to 
     #     the same directory that CATALINA_HOME points to. 
     # 
     # CATALINA_OUT (Optional) Full path to a file where stdout and stderr 
     #     will be redirected. 
     #     Default is $CATALINA_BASE/logs/catalina.out 
     # 
     # CATALINA_OPTS (Optional) Java runtime options used when the "start", 
     #     or "run" command is executed. 
     # 
     # CATALINA_TMPDIR (Optional) Directory path location of temporary directory 
     #     the JVM should use (java.io.tmpdir). Defaults to 
     #     $CATALINA_BASE/temp. 
     # 
     # JAVA_HOME  Must point at your Java Development Kit installation. 
     #     Required to run the with the "debug" argument. 
     # 
     # JRE_HOME  Must point at your Java Development Kit installation. 
     #     Defaults to JAVA_HOME if empty. 
     # 
     # JAVA_OPTS  (Optional) Java runtime options used when the "start", 
     #     "stop", or "run" command is executed. 
     # 
     # JAVA_ENDORSED_DIRS (Optional) Lists of of colon separated directories 
     #     containing some jars in order to allow replacement of APIs 
     #     created outside of the JCP (i.e. DOM and SAX from W3C). 
     #     It can also be used to update the XML parser implementation. 
     #     Defaults to $CATALINA_HOME/endorsed. 
     # 
     # JPDA_TRANSPORT (Optional) JPDA transport used when the "jpda start" 
     #     command is executed. The default is "dt_socket". 
     # 
     # JPDA_ADDRESS (Optional) Java runtime options used when the "jpda start" 
     #     command is executed. The default is 8000. 
     # 
     # JPDA_SUSPEND (Optional) Java runtime options used when the "jpda start" 
     #     command is executed. Specifies whether JVM should suspend 
     #     execution immediately after startup. Default is "n". 
     # 
     # JPDA_OPTS  (Optional) Java runtime options used when the "jpda start" 
     #     command is executed. If used, JPDA_TRANSPORT, JPDA_ADDRESS, 
     #     and JPDA_SUSPEND are ignored. Thus, all required jpda 
     #     options MUST be specified. The default is: 
     # 
     #     -agentlib:jdwp=transport=$JPDA_TRANSPORT, 
     #      address=$JPDA_ADDRESS,server=y,suspend=$JPDA_SUSPEND 
     # 
     # CATALINA_PID (Optional) Path of the file which should contains the pid 
     #     of catalina startup java process, when start (fork) is used 
     # 
     # LOGGING_CONFIG (Optional) Override Tomcat's logging config file 
     #     Example (all one line) 
     #     LOGGING_CONFIG="-Djava.util.logging.config.file=$CATALINA_BASE/conf/logging.properties" 
     # 
     # LOGGING_MANAGER (Optional) Override Tomcat's logging manager 
     #     Example (all one line) 
     #     LOGGING_MANAGER="-Djava.util.logging.manager=org.apache.juli.ClassLoaderLogManager" 
     # 
     # $Id: catalina.sh 1040547 2010-11-30 14:47:49Z markt $ 
     # ----------------------------------------------------------------------------- 

     # OS specific support. $var _must_ be set to either true or false. 
     cygwin=false 
     os400=false 
     darwin=false 
     case "`uname`" in 
     CYGWIN*) cygwin=true;; 
     OS400*) os400=true;; 
     Darwin*) darwin=true;; 
     esac 

     # resolve links - $0 may be a softlink 
     PRG="$0" 

     while [ -h "$PRG" ]; do 
      ls=`ls -ld "$PRG"` 
      link=`expr "$ls" : '.*-> \(.*\)$'` 
      if expr "$link" : '/.*' > /dev/null; then 
       PRG="$link" 
      else 
       PRG=`dirname "$PRG"`/"$link" 
      fi 
     done 

     # Get standard environment variables 
     PRGDIR=`dirname "$PRG"` 

     # Only set CATALINA_HOME if not already set 
     [ -z "$CATALINA_HOME" ] && CATALINA_HOME=`cd "$PRGDIR/.." >/dev/null; pwd` 

     # Ensure that any user defined CLASSPATH variables are not used on startup, 
     # but allow them to be specified in setenv.sh, in rare case when it is needed. 
     CLASSPATH= 

     if [ -r "$CATALINA_BASE"/bin/setenv.sh ]; then 
      . "$CATALINA_BASE"/bin/setenv.sh 
     elif [ -r "$CATALINA_HOME"/bin/setenv.sh ]; then 
      . "$CATALINA_HOME"/bin/setenv.sh 
     fi 

     # For Cygwin, ensure paths are in UNIX format before anything is touched 
     if $cygwin; then 
      [ -n "$JAVA_HOME" ] && JAVA_HOME=`cygpath --unix "$JAVA_HOME"` 
      [ -n "$JRE_HOME" ] && JRE_HOME=`cygpath --unix "$JRE_HOME"` 
      [ -n "$CATALINA_HOME" ] && CATALINA_HOME=`cygpath --unix "$CATALINA_HOME"` 
      [ -n "$CATALINA_BASE" ] && CATALINA_BASE=`cygpath --unix "$CATALINA_BASE"` 
      [ -n "$CLASSPATH" ] && CLASSPATH=`cygpath --path --unix "$CLASSPATH"` 
     fi 

     # For OS400 
     if $os400; then 
      # Set job priority to standard for interactive (interactive - 6) by using 
      # the interactive priority - 6, the helper threads that respond to requests 
      # will be running at the same priority as interactive jobs. 
      COMMAND='chgjob job('$JOBNAME') runpty(6)' 
      system $COMMAND 

      # Enable multi threading 
      export QIBM_MULTI_THREADED=Y 
     fi 

     # Get standard Java environment variables 
     if $os400; then 
      # -r will Only work on the os400 if the files are: 
      # 1. owned by the user 
      # 2. owned by the PRIMARY group of the user 
      # this will not work if the user belongs in secondary groups 
      BASEDIR="$CATALINA_HOME" 
      . "$CATALINA_HOME"/bin/setclasspath.sh 
     else 
      if [ -r "$CATALINA_HOME"/bin/setclasspath.sh ]; then 
       BASEDIR="$CATALINA_HOME" 
       . "$CATALINA_HOME"/bin/setclasspath.sh 
      else 
       echo "Cannot find $CATALINA_HOME/bin/setclasspath.sh" 
       echo "This file is needed to run this program" 
       exit 1 
      fi 
     fi 

     if [ -z "$CATALINA_BASE" ] ; then 
      CATALINA_BASE="$CATALINA_HOME" 
     fi 

     # Add tomcat-juli.jar and bootstrap.jar to classpath 
     # tomcat-juli.jar can be over-ridden per instance 
     if [ ! -z "$CLASSPATH" ] ; then 
      CLASSPATH="$CLASSPATH": 
     fi 
     if [ "$CATALINA_BASE" != "$CATALINA_HOME" ] && [ -r "$CATALINA_BASE/bin/tomcat-juli.jar" ] ; then 
      CLASSPATH="$CLASSPATH""$CATALINA_BASE"/bin/tomcat-juli.jar:"$CATALINA_HOME"/bin/bootstrap.jar 
     else 
      CLASSPATH="$CLASSPATH""$CATALINA_HOME"/bin/bootstrap.jar 
     fi 

     if [ -z "$CATALINA_OUT" ] ; then 
      CATALINA_OUT="$CATALINA_BASE"/logs/catalina.out 
     fi 

     if [ -z "$CATALINA_TMPDIR" ] ; then 
      # Define the java.io.tmpdir to use for Catalina 
      CATALINA_TMPDIR="$CATALINA_BASE"/temp 
     fi 

     # Bugzilla 37848: When no TTY is available, don't output to console 
     have_tty=0 
     if [ "`tty`" != "not a tty" ]; then 
       have_tty=1 
     fi 

     # For Cygwin, switch paths to Windows format before running java 
     if $cygwin; then 
      JAVA_HOME=`cygpath --absolute --windows "$JAVA_HOME"` 
      JRE_HOME=`cygpath --absolute --windows "$JRE_HOME"` 
      CATALINA_HOME=`cygpath --absolute --windows "$CATALINA_HOME"` 
      CATALINA_BASE=`cygpath --absolute --windows "$CATALINA_BASE"` 
      CATALINA_TMPDIR=`cygpath --absolute --windows "$CATALINA_TMPDIR"` 
      CLASSPATH=`cygpath --path --windows "$CLASSPATH"` 
      JAVA_ENDORSED_DIRS=`cygpath --path --windows "$JAVA_ENDORSED_DIRS"` 
     fi 

     # Set juli LogManager config file if it is present and an override has not been issued 
     if [ -z "$LOGGING_CONFIG" ]; then 
      if [ -r "$CATALINA_BASE"/conf/logging.properties ]; then 
       LOGGING_CONFIG="-Djava.util.logging.config.file=$CATALINA_BASE/conf/logging.properties" 
      else 
       # Bugzilla 45585 
       LOGGING_CONFIG="-Dnop" 
      fi 
     fi 

     if [ -z "$LOGGING_MANAGER" ]; then 
      JAVA_OPTS="$JAVA_OPTS -Djava.util.logging.manager=org.apache.juli.ClassLoaderLogManager" 
     else 
      JAVA_OPTS="$JAVA_OPTS $LOGGING_MANAGER" 
     fi 

     # ----- Execute The Requested Command ----------------------------------------- 

     # Bugzilla 37848: only output this if we have a TTY 
     if [ $have_tty -eq 1 ]; then 
      echo "Using CATALINA_BASE: $CATALINA_BASE" 
      echo "Using CATALINA_HOME: $CATALINA_HOME" 
      echo "Using CATALINA_TMPDIR: $CATALINA_TMPDIR" 
      if [ "$1" = "debug" ] ; then 
       echo "Using JAVA_HOME:  $JAVA_HOME" 
      else 
       echo "Using JRE_HOME:  $JRE_HOME" 
      fi 
      echo "Using CLASSPATH:  $CLASSPATH" 
      if [ ! -z "$CATALINA_PID" ]; then 
       # Added by Jignesh Gohel - Nov 08, 2011. 

       # There was an issue occuring when shutting down tomcat using 
       # command ./catalina.sh stop 

       # Issue mentioned at : http://stackoverflow.com/questions/7890197/facing-some-issues-regarding-tomcat-startup-and-shutdown-on-ubuntu-10-04 

       # Tomcat was shutting down properly but the process started using 
       # command ./catalina.sh start was not getting killed. 

       # To resolve this issue following steps taken :- 

       # 1) Exported an environment variable named CATALINA_PID which 
       # should point to a file in which the tomcat process id would be 
       # written. 

       # Note: Using the normal command to shutdown tomcat "./catalina.sh stop" 
       # following message was logged "Tomcat did not stop in time. PID file 
       # was not removed".Thus to shutdown the tomcat using following command 
       # "./catalina.sh stop -force" which forcefully kills the tomcat process 
       # and also removes the file pointed by environment variable 
       # "$CATALINA_PID".Thus executing a "touch" command when starting up 
       # tomcat to automatically create the file. 

       touch "$CATALINA_PID" 
       echo "Using CATALINA_PID: $CATALINA_PID" 
      fi 
     fi 

     if [ "$1" = "jpda" ] ; then 
      if [ -z "$JPDA_TRANSPORT" ]; then 
       JPDA_TRANSPORT="dt_socket" 
      fi 
      if [ -z "$JPDA_ADDRESS" ]; then 
       JPDA_ADDRESS="8000" 
      fi 
      if [ -z "$JPDA_SUSPEND" ]; then 
       JPDA_SUSPEND="n" 
      fi 
      if [ -z "$JPDA_OPTS" ]; then 
       JPDA_OPTS="-agentlib:jdwp=transport=$JPDA_TRANSPORT,address=$JPDA_ADDRESS,server=y,suspend=$JPDA_SUSPEND" 
      fi 
      CATALINA_OPTS="$CATALINA_OPTS $JPDA_OPTS" 
      shift 
     fi 

     if [ "$1" = "debug" ] ; then 
      if $os400; then 
       echo "Debug command not available on OS400" 
       exit 1 
      else 
       shift 
       if [ "$1" = "-security" ] ; then 
        if [ $have_tty -eq 1 ]; then 
         echo "Using Security Manager" 
        fi 
        shift 
        exec "$_RUNJDB" "$LOGGING_CONFIG" $JAVA_OPTS $CATALINA_OPTS \ 
         -Djava.endorsed.dirs="$JAVA_ENDORSED_DIRS" -classpath "$CLASSPATH" \ 
         -sourcepath "$CATALINA_HOME"/../../java \ 
         -Djava.security.manager \ 
         -Djava.security.policy=="$CATALINA_BASE"/conf/catalina.policy \ 
         -Dcatalina.base="$CATALINA_BASE" \ 
         -Dcatalina.home="$CATALINA_HOME" \ 
         -Djava.io.tmpdir="$CATALINA_TMPDIR" \ 
         org.apache.catalina.startup.Bootstrap "[email protected]" start 
       else 
        exec "$_RUNJDB" "$LOGGING_CONFIG" $JAVA_OPTS $CATALINA_OPTS \ 
         -Djava.endorsed.dirs="$JAVA_ENDORSED_DIRS" -classpath "$CLASSPATH" \ 
         -sourcepath "$CATALINA_HOME"/../../java \ 
         -Dcatalina.base="$CATALINA_BASE" \ 
         -Dcatalina.home="$CATALINA_HOME" \ 
         -Djava.io.tmpdir="$CATALINA_TMPDIR" \ 
         org.apache.catalina.startup.Bootstrap "[email protected]" start 
       fi 
      fi 

     elif [ "$1" = "run" ]; then 

      shift 
      if [ "$1" = "-security" ] ; then 
       if [ $have_tty -eq 1 ]; then 
        echo "Using Security Manager" 
       fi 
       shift 
       exec "$_RUNJAVA" "$LOGGING_CONFIG" $JAVA_OPTS $CATALINA_OPTS \ 
        -Djava.endorsed.dirs="$JAVA_ENDORSED_DIRS" -classpath "$CLASSPATH" \ 
        -Djava.security.manager \ 
        -Djava.security.policy=="$CATALINA_BASE"/conf/catalina.policy \ 
        -Dcatalina.base="$CATALINA_BASE" \ 
        -Dcatalina.home="$CATALINA_HOME" \ 
        -Djava.io.tmpdir="$CATALINA_TMPDIR" \ 
        org.apache.catalina.startup.Bootstrap "[email protected]" start 
      else 
       exec "$_RUNJAVA" "$LOGGING_CONFIG" $JAVA_OPTS $CATALINA_OPTS \ 
        -Djava.endorsed.dirs="$JAVA_ENDORSED_DIRS" -classpath "$CLASSPATH" \ 
        -Dcatalina.base="$CATALINA_BASE" \ 
        -Dcatalina.home="$CATALINA_HOME" \ 
        -Djava.io.tmpdir="$CATALINA_TMPDIR" \ 
        org.apache.catalina.startup.Bootstrap "[email protected]" start 
      fi 

     elif [ "$1" = "start" ] ; then 

      if [ ! -z "$CATALINA_PID" ]; then 
       if [ -f "$CATALINA_PID" ]; then 
        if [ -s "$CATALINA_PID" ]; then 
         echo "Existing PID file found during start." 
         if [ -r "$CATALINA_PID" ]; then 
          PID=`cat "$CATALINA_PID"` 
          ps -p $PID >/dev/null 2>&1 
          if [ $? -eq 0 ] ; then 
           echo "Tomcat appears to still be running with PID $PID. Start aborted." 
           exit 1 
          else 
           echo "Removing/clearing stale PID file." 
           rm -f "$CATALINA_PID" >/dev/null 2>&1 
           if [ $? != 0 ]; then 
            if [ -w "$CATALINA_PID" ]; then 
             cat /dev/null > "$CATALINA_PID" 
            else 
             echo "Unable to remove or clear stale PID file. Start aborted." 
             exit 1 
            fi 
           fi 
          fi 
         else 
          echo "Unable to read PID file. Start aborted." 
          exit 1 
         fi 
        else 
         rm -f "$CATALINA_PID" >/dev/null 2>&1 
         if [ $? != 0 ]; then 
          if [ ! -w "$CATALINA_PID" ]; then 
           echo "Unable to remove or write to empty PID file. Start aborted." 
           exit 1 
          fi 
         fi 
        fi 
       fi 
      fi 

      shift 
      touch "$CATALINA_OUT" 
      if [ "$1" = "-security" ] ; then 
       if [ $have_tty -eq 1 ]; then 
        echo "Using Security Manager" 
       fi 
       shift 
       "$_RUNJAVA" "$LOGGING_CONFIG" $JAVA_OPTS $CATALINA_OPTS \ 
        -Djava.endorsed.dirs="$JAVA_ENDORSED_DIRS" -classpath "$CLASSPATH" \ 
        -Djava.security.manager \ 
        -Djava.security.policy=="$CATALINA_BASE"/conf/catalina.policy \ 
        -Dcatalina.base="$CATALINA_BASE" \ 
        -Dcatalina.home="$CATALINA_HOME" \ 
        -Djava.io.tmpdir="$CATALINA_TMPDIR" \ 
        org.apache.catalina.startup.Bootstrap "[email protected]" start \ 
        >> "$CATALINA_OUT" 2>&1 & 

      else 
       "$_RUNJAVA" "$LOGGING_CONFIG" $JAVA_OPTS $CATALINA_OPTS \ 
        -Djava.endorsed.dirs="$JAVA_ENDORSED_DIRS" -classpath "$CLASSPATH" \ 
        -Dcatalina.base="$CATALINA_BASE" \ 
        -Dcatalina.home="$CATALINA_HOME" \ 
        -Djava.io.tmpdir="$CATALINA_TMPDIR" \ 
        org.apache.catalina.startup.Bootstrap "[email protected]" start \ 
        >> "$CATALINA_OUT" 2>&1 & 

      fi 

      if [ ! -z "$CATALINA_PID" ]; then 
       echo $! > "$CATALINA_PID" 
      fi 

     elif [ "$1" = "stop" ] ; then 

      shift 

      SLEEP=5 
      if [ ! -z "$1" ]; then 
       echo $1 | grep "[^0-9]" >/dev/null 2>&1 
       if [ $? -gt 0 ]; then 
        SLEEP=$1 
        shift 
       fi 
      fi 

      FORCE=0 
      if [ "$1" = "-force" ]; then 
       shift 
       FORCE=1 
      fi 

      if [ ! -z "$CATALINA_PID" ]; then 
       if [ -s "$CATALINA_PID" ]; then 
        if [ -f "$CATALINA_PID" ]; then 
         kill -0 `cat "$CATALINA_PID"` >/dev/null 2>&1 
         if [ $? -gt 0 ]; then 
          echo "PID file found but no matching process was found. Stop aborted." 
          exit 1 
         fi 
        else 
         echo "\$CATALINA_PID was set but the specified file does not exist. Is Tomcat running? Stop aborted." 
         exit 1 
        fi 
       else 
        echo "PID file is empty and has been ignored." 
       fi 
      fi 

      "$_RUNJAVA" $JAVA_OPTS \ 
       -Djava.endorsed.dirs="$JAVA_ENDORSED_DIRS" -classpath "$CLASSPATH" \ 
       -Dcatalina.base="$CATALINA_BASE" \ 
       -Dcatalina.home="$CATALINA_HOME" \ 
       -Djava.io.tmpdir="$CATALINA_TMPDIR" \ 
       org.apache.catalina.startup.Bootstrap "[email protected]" stop 

      if [ ! -z "$CATALINA_PID" ]; then 
       if [ -f "$CATALINA_PID" ]; then 
        while [ $SLEEP -ge 0 ]; do 
         kill -0 `cat "$CATALINA_PID"` >/dev/null 2>&1 
         if [ $? -gt 0 ]; then 
          rm -f "$CATALINA_PID" >/dev/null 2>&1 
          if [ $? != 0 ]; then 
           if [ -w "$CATALINA_PID" ]; then 
            cat /dev/null > "$CATALINA_PID" 
           else 
            echo "Tomcat stopped but the PID file could not be removed or cleared." 
           fi 
          fi 
          break 
         fi 
         if [ $SLEEP -gt 0 ]; then 
          sleep 1 
         fi 
         if [ $SLEEP -eq 0 ]; then 
          if [ $FORCE -eq 0 ]; then 
           echo "Tomcat did not stop in time. PID file was not removed." 
          fi 
         fi 
         SLEEP=`expr $SLEEP - 1 ` 
        done 
       fi 
      fi 

      if [ $FORCE -eq 1 ]; then 
       if [ -z "$CATALINA_PID" ]; then 
        echo "Kill failed: \$CATALINA_PID not set" 
       else 
        if [ -f "$CATALINA_PID" ]; then 
         PID=`cat "$CATALINA_PID"` 
         echo "Killing Tomcat with the PID: $PID" 
         kill -9 $PID 
         rm -f "$CATALINA_PID" >/dev/null 2>&1 
         if [ $? != 0 ]; then 
          echo "Tomcat was killed but the PID file could not be removed." 
         fi 
        fi 
       fi 
      fi 

     elif [ "$1" = "version" ] ; then 

       "$_RUNJAVA" \ 
        -classpath "$CATALINA_HOME/lib/catalina.jar" \ 
        org.apache.catalina.util.ServerInfo 

     else 

      echo "Usage: catalina.sh (commands ...)" 
      echo "commands:" 
      if $os400; then 
       echo " debug    Start Catalina in a debugger (not available on OS400)" 
       echo " debug -security Debug Catalina with a security manager (not available on OS400)" 
      else 
       echo " debug    Start Catalina in a debugger" 
       echo " debug -security Debug Catalina with a security manager" 
      fi 
      echo " jpda start  Start Catalina under JPDA debugger" 
      echo " run    Start Catalina in the current window" 
      echo " run -security  Start in the current window with security manager" 
      echo " start    Start Catalina in a separate window" 
      echo " start -security Start in a separate window with security manager" 
      echo " stop    Stop Catalina, waiting up to 5 seconds for the process to end" 
      echo " stop n   Stop Catalina, waiting up to n seconds for the process to end" 
      echo " stop -force  Stop Catalina, wait up to 5 seconds and then use kill -KILL if still running" 
      echo " stop n -force  Stop Catalina, wait up to n seconds and then use kill -KILL if still running" 
      echo " version   What version of tomcat are you running?" 
      echo "Note: Waiting for the process to end and use of the -force option require that \$CATALINA_PID is defined" 
      exit 1 

     fi

感谢，

Jignesh

来源

2012-05-25 14:57:45

，因为你用它来启动tomcat（在正常或调试模式）地址已由另一过程中的问题引起的。

您需要检查您在conf文件中使用的端口（例如your_TOMCAT_HOME_DIR_/conf/server。XML），看看他们是不是已经使用

在这里，你可以看看用于

启动Tomcat的端口：使用默认值8005
：默认值8080
停止Tomcat AJP protocoll：默认值8009

，如果你是在调试模式（通过jdpa或JDWP）使用Tomcat，请务必使用不同的端口比之前所有的配置端口

来源

2011-11-04 18:41:53 arthur

在我对这个问题的场景中，有一些线程没有成功地终止发布给tomcat的关闭消息，这使得tomcat进程仍然处于闲置状态。

所以我会从纯粹的tomcat实例开始......并不断添加自定义“战争”或逐个更改，并确保成功阻止tomcat以缩小问题范围。

来源

2011-12-01 21:42:07

这是要测试的东西，但你认为它会解释所有的症状吗？ – itsbruce

解决方案; 首先设置tomcat的 CATALINA_PID =的PID “/ id.pid” 出口CATALINA_PID

然后杀死它 catalina.sh停止-force

来源：http://confluence.atlassian.com/pages/viewpage.action?pageId=216959212

否则就像你提到的，只是kill命令

ps aux | grep catalina 
kill <pid of tomcat>

杀死它，如果上述两个解决方案不适合你的东东DS尝试以下操作：

$ sudo service tomcat6 stop 
* Stopping Tomcat servlet engine tomcat6 [ OK ] 
$ sudo service tomcat6 start 
* Starting Tomcat servlet engine tomcat6 [ OK ] 
$

或课程的更传统的方式：

$ sudo /etc/init.d/tomcat6 stop 
* Stopping Tomcat servlet engine tomcat6 [ OK ] 
$ sudo /etc/init.d/tomcat6 start 
* Starting Tomcat ser

来源

2012-02-28 15:02:26 Ben

不要使用/etc/bash.bashrc 只是把这个在您的catalina.sh

后：

if [ -r "$CATALINA_BASE"/bin/setenv.sh ]; then 
      . "$CATALINA_BASE"/bin/setenv.sh 
     elif [ -r "$CATALINA_HOME"/bin/setenv.sh ]; then 
      . "$CATALINA_HOME"/bin/setenv.sh 
     fi

把这个：

export CATALINA_PID="$CATALINA_HOME/catalina_pid.txt"

现在你的tomcat会被杀死，当您使用卡塔利娜。SH停止-force

来源

2012-07-06 07:37:50

最简单的解决方案，谢谢。 –

我认为官方推荐的方式（根据内嵌的catalina.sh评论）是：

下创建$ CATALINA_HOME/bin中一个setenv.sh文件：

＃！/ bin/sh

CATALINA_PID =“$ CATALINA_HOME/logs/catalina.pid”;出口CATALINA_PID

文件模式为可执行：

CHMOD U + X setenv.sh
通过创建pid文件：

触摸$ CATALINA_HOME /日志/卡塔利娜.pid
然后照常启动tomcat，pid文件会自动更新。你也可以通过“-force”选项来阻止tomcat。

来源

2017-01-06 05:02:52 Tomofumi

下面的命令做的伎俩：

service tomcat8 stop

这些的人会有帮助过：

service tomcat8 start

service tomcat8 restart

来源

2017-09-19 19:12:01 Josafat

面对一些关于在Ubuntu 10.04上启动和关闭tomcat的问题

回答

相关问题