在ubuntu10.04上面对一些关于tomcat启动和关闭的问题。

I am facing some issues regarding tomcat startup and shutdown.

我面临一些关于tomcat启动和关闭的问题。

I am using

我用

1. Tomcat v.6.0.32 (using the extracted the bundle downloaded from Apache website and not the one distributed by Ubuntu 10.04)
2. Tomcat v.6.0.32(使用从Apache网站下载的包，而不是Ubuntu 10.04分发的包)
3. Ubuntu v.10.04
4. Ubuntu v.10.04

I start the tomcat using command:

我使用命令启动tomcat:

$./catalina.sh jpda start

Then I try to stop it using command:

然后我试着用命令来阻止它:

$./catalina.sh stop

and get the following message:

并得到以下信息:

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)

I also tried stopping it using command :

我还试着用命令阻止它:

$./catalina.sh stop -force

but I got the message:

但我得到的信息是:

Kill failed: $CATALINA_PID not set

Then I again tried starting tomcat using command:

然后，我再次尝试使用命令启动tomcat:

$./catalina.sh jpda start

In the /logs folder only catalina.out is generated with following error message:

在/logs文件夹中只有catalina。输出如下错误信息:

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)

As it is indicated in the error "Address already in use" I verified no other application is configured to run on port 8080. Everytime when I kill the process id and restart it, the startup works fine.This requires me to kill the process manually using "KILL" command, when I need to stop the tomcat server. This same behavior I am encountering on other machines too where same environment as mentioned above is set up.

正如在错误“已使用的地址”中所指出的，我验证没有其他应用程序被配置为在端口8080上运行。每次当我杀死进程id并重新启动它时，启动程序就可以正常工作了。这要求我在需要停止tomcat服务器时，用“kill”命令手动杀死进程。我在其他机器上也遇到了同样的行为，上面提到的环境也是相同的。

Can anybody please let me know what is causing this and how to resolve this?

谁能告诉我是什么导致了这个问题以及如何解决这个问题?

Thanks,
Jignesh

谢谢,Jignesh

7 个解决方案

#1

Dont use /etc/bash.bashrc just put this on your catalina.sh

不要使用/etc/bash.bashrc把这个放在你的catalina.sh上。

After:

后:

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

put this:

把这个:

export CATALINA_PID="$CATALINA_HOME/catalina_pid.txt"

And now your tomcat will be killed when you use catalina.sh stop -force

而现在，当你使用catalina时，你的tomcat将被杀死。sh停止force

#2

Solution; First set the pid of tomcat CATALINA_PID="/id.pid" export CATALINA_PID

解决方案;首先设置tomcat CATALINA_PID="/id " pid。pid“出口CATALINA_PID

then kill it catalina.sh stop -force

然后杀了卡特琳娜。sh停止force

source: http://confluence.atlassian.com/pages/viewpage.action?pageId=216959212

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

otherwise just as you mentioned, just kill it with the kill command

否则就像你刚才提到的，用kill命令杀死它。

ps aux | grep catalina
kill <pid of tomcat>

if the above two solutions don't fit your needs try the following:

如果以上两个解决方案不适合您的需要，请尝试以下步骤:

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

or of course the more traditional way:

或者更传统的方式:

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

#3

Fixed the tomcat shutdown issue.Posting the solution here for reference.

修正了tomcat关机问题。在这里张贴解决方案供参考。

Do the following to fix it on your machine:

在你的机器上做以下操作:

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 - contains my inline comments

卡特琳娜。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://*.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 "$@" 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 "$@" 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 "$@" 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 "$@" 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 "$@" 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 "$@" 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 "$@" 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

Thanks,

谢谢,

Jignesh

Jignesh

#4

The problem is caused because the address you use to start tomcat (in normal or debug mode) is already taken by another process.

问题是由于您用于启动tomcat(正常或调试模式)的地址已经被另一个进程所占用。

You need to check the ports you are using in the you conf file (e.g. your_TOMCAT_HOME_DIR_/conf/server.xml), to see if they are not already used

您需要检查在您的conf文件中使用的端口(例如:your_TOMCAT_HOME_DIR_/conf/server.xml)，以查看它们是否已经被使用。

Here you can look at the port used for

在这里，您可以查看所使用的端口。

• starting Tomcat: default value 8080
• 启动Tomcat:默认值8080。
• stopping Tomcat: default value 8005
• 停止Tomcat:默认值8005。
• using with AJP protocoll: default value 8009
• 使用AJP协议:默认值8009。

and if you are using Tomcat in debug mode (through jdpa or jdwp ), please make sure to use a different port than all the previous configured ports

如果您在调试模式中使用Tomcat(通过jdpa或jdwp)，请确保使用的端口与之前所有配置的端口不同。

#5

In my scenario to this problem, there were some threads not successfully terminated with shutdown message posted to tomcat, which made tomcat process still hanging around.

在这个问题的场景中，有一些线程没有成功地终止与tomcat的关机消息，这使得tomcat进程仍然在运行。

So I would start with plain tomcat instance..and keep adding the custom "wars" or changes one by one and make sure to stop tomcat successfully to narrow down the problem.

因此，我将以普通tomcat实例开始。并且不断添加定制的“战争”或一个接一个的更改，并确保停止tomcat成功地缩小问题。

#6

I think the officially recommended way (according to catalina.sh inline comments) is:

我认为是官方推荐的方式(根据卡特琳娜的说法)。sh内联注释):

• create a setenv.sh file under $CATALINA_HOME/bin:
• 创建一个setenv。sh CATALINA_HOME美元/ bin目录下的文件:

#!/bin/sh

# ! / bin / sh

CATALINA_PID="$CATALINA_HOME/logs/catalina.pid"; export CATALINA_PID

CATALINA_PID = " $ CATALINA_HOME /日志/ catalina.pid ";出口CATALINA_PID

• chmod as executable:

  chmod u+x setenv.sh

  chmod u + x setenv.sh

• create the pid file by:

  touch $CATALINA_HOME/logs/catalina.pid

  触摸CATALINA_HOME美元/日志/ catalina.pid

• then startup tomcat as usual, the pid file will be updated automatically. And you can stop tomcat by "-force" option as well.
• 然后像往常一样启动tomcat，将自动更新pid文件。您也可以通过“-force”选项阻止tomcat。

#7

Following command does the trick:

下面的命令就是:

service tomcat8 stop

These ones would be helpful too:

这些方法也很有用:

service tomcat8 start

service tomcat8 restart