{"id":10224,"date":"2021-03-01T06:10:00","date_gmt":"2021-03-01T14:10:00","guid":{"rendered":"https:\/\/www.coretechnologies.com\/blog\/?p=10224"},"modified":"2025-12-10T19:19:27","modified_gmt":"2025-12-11T03:19:27","slug":"stop-srvany-service","status":"publish","type":"post","link":"https:\/\/www.coretechnologies.com\/blog\/srvany\/stop-srvany-service\/","title":{"rendered":"Q&A: Why doesn’t Srvany Close my Application when I Stop the Service?"},"content":{"rendered":"
\"Q&A:<\/div>\n
\n  We use Srvany<\/a> to run our Java application as a service. It starts fine but when we stop the service our Java application does not close. We have to kill the java.exe process in Task Manager. That’s not supposed to happen, right? Is there a registry setting that we are missing that will shut down our application properly when we stop the service?<\/p>\n

— Angela<\/p>\n<\/div>\n

Hi Angela.<\/p>\n

As you probably know, Srvany is the original service wrapper<\/a>. Its job is to accept commands from the Windows Service Control Manager (SCM)<\/a> and take appropriate action on your java application. Simple, right?<\/p>\n

Well, maybe not. Let’s examine what Microsoft’s service wrapper does when it receives the most important SCM commands — “start service” and “stop service”.<\/p>\n

\n
\n
\"\"<\/a><\/div>\n<\/div>\n

How Srvany handles the “Start Service” command<\/h2>\n

When you start your service — from the Services application<\/a>, NET START<\/a>, or SC START<\/a> — the SCM immediately launches a fresh instance of srvany.exe and notifies it of the start request. <\/p>\n

In response, Srvany:<\/p>\n

    \n
  1. \n

    Informs the SCM that the service is starting.<\/p>\n<\/li>\n

  2. \n

    Starts the program configured to run as a service. The full command line is read from this registry value:<\/p>\n

    HKEY_LOCAL_MACHINE\\SYSTEM\\CurrentControlSet\\Services\\<Your Service>\\Parameters\\Application<\/b><\/p><\/blockquote>\n<\/li>\n<\/ol>\n

    If Srvany fails to start the application (which will happen if the application\/path doesn’t exist), Srvany will:<\/p>\n

      \n
    1. \n

      Inform the SCM that the service has stopped.<\/p>\n<\/li>\n

    2. \n

      Exit, ending the srvany.exe process.<\/p>\n<\/li>\n<\/ol>\n

      On the other hand, if it successfully launches the application, Srvany will:<\/p>\n

        \n
      1. \n

        Inform the SCM that the service is now running.<\/p>\n<\/li>\n

      2. \n

        Continue to run, listening for subsequent commands from the SCM.<\/p>\n<\/li>\n<\/ol>\n

        Testing service start with Notepad<\/h3>\n

        To confirm this behavior, we installed a new service (with Instsrv) and configured it to run the Windows Notepad text editor:<\/p>\n

        \"Notepad<\/a><\/div>\n

        We started the service. <\/p>\n

        With the help of Microsoft’s excellent Process Explorer<\/a>, here is what the process tree looked like after a few seconds. As expected, there was a srvany.exe process that had spawned a notepad.exe child process:<\/p>\n

        \"Srvany<\/a><\/div>\n

        And Notepad was happily running in the background, on the isolated Session 0 desktop.<\/p>\n

        \n
        \n
        \"\"<\/a><\/div>\n<\/div>\n

        How Srvany handles the “Stop Service” command<\/h2>\n

        When you attempt to stop your service — from the Services application<\/a>, NET STOP<\/a>, or SC STOP<\/a> — the SCM immediately notifies the associated Srvany process of the stop request.<\/p>\n

        In response, Srvany will:<\/p>\n

          \n
        1. \n

          Inform the SCM that the service is stopping.<\/p>\n<\/li>\n

        2. \n

          Close the process\/application that it started.<\/p>\n<\/li>\n

        3. \n

          Inform the SCM that the service is stopped.<\/p>\n<\/li>\n

        4. \n

          Exit, ending the srvany.exe process.<\/p>\n<\/li>\n<\/ol>\n

          When we stopped the Notepad service, Notepad.exe was terminated as expected.<\/p>\n

          But what happens when running a Java application\/service?<\/h3>\n

          Since stopping your Java application didn’t go smoothly, we decided to dig into that specific scenario. <\/p>\n

          We installed a new service and configured it to launch a Java JAR package:<\/p>\n

          \"Java\/JAR<\/a><\/div>\n

          When we started the service, we saw srvany.exe launch java.exe. No surprises there:<\/p>\n

          \"Srvany<\/a><\/div>\n

          And when we stopped the service, the java.exe process ended and Srvany exited — all good.<\/p>\n

          So how come it isn’t working for you?<\/p>\n

          What about a Java application started from a batch file?<\/h3>\n

          After some head scratching, we realized something important. Many of our customers running Java as a service with AlwaysUp<\/a> don’t run java directly. Instead, they start java via a batch file because it gives them the opportunity to set important environment variables in advance. Could that be an issue?<\/p>\n

          To answer that question, we created a simple batch file that launched java and installed a new service to run the batch file:<\/p>\n

          \"Batch<\/a><\/div>\n

          We started the service. Srvany launched the batch file (cmd.exe), which in turn launched Java — all as intended:<\/p>\n

          \"Srvany<\/a><\/div>\n

          However, when tried to stop the service, something unexpected happened. The service stopped and srvany.exe and cmd.exe closed, but java.exe did not exit! The Java process remained running, even after the service had transitioned to the stopped state. It was exactly as you described.<\/p>\n

          So from these tests, it seems that Srvany will terminate the process it launched (i.e. its direct child process) but will not terminate any descendant processes<\/b>.<\/p>\n

          Do you think this is what you are experiencing? If so, please read on for a couple of potential solutions.<\/p>\n

          \n
          \n
          \"\"<\/a><\/div>\n<\/div>\n

          Solution #1: Run the Java executable directly from Srvany<\/h2>\n

          Instead of starting Java from a batch file, let Srvany run your Java.exe command line itself. As we have shown above, Srvany is able to terminate Java when it launches it directly.<\/p>\n

          However, this option may be impractical if your batch file performs lots of setup. But if the batch file focuses on setting environment variables (e.g. CLASSPATH), you can get around that by:<\/p>\n

            \n
          1. \n

            Permanently setting the environment variables in a specific user account, and<\/p>\n<\/li>\n

          2. \n

            Running Java in that account (by specifying the user’s details on the service’s Log On tab).<\/p>\n<\/li>\n<\/ol>\n

            \n
            \n
            \"\"<\/a><\/div>\n<\/div>\n

            Solution #2: Install your Java application as a service with AlwaysUp instead of Srvany<\/h2>\n

            Alternatively, if this is a professional setting and a commercial option is acceptable, you can replace Srvany with our AlwaysUp<\/a> utility.<\/p>\n

            When you stop a service created by AlwaysUp, all descendant processes are terminated<\/b>. That is, AlwaysUp will close cmd.exe, java.exe — and any other processes that your Java application spawns. You will never have a situation where your service is stopped but some processes remain alive.<\/p>\n

            Please review the benefits to using AlwaysUp instead of Srvany<\/a> to see if you should make the switch.<\/p>\n

            \n
            \n
            \"\"<\/a><\/div>\n<\/div>\n

            \nBest of luck managing your Java application!<\/p>\n