How to Daemonize a Java Program?

I have a Java program that I'd like to daemonize on a linux system. In other words, I want to start running it in a shell and have it continue running after I've logged out. I also want to be able to stop the program cleanly.

I found this article which uses a combination of shell scripting and Java code to do the trick. It looks good, but I'd like something simpler, if possible.

What's your preferred method to daemonize a Java program on a Linux system?

From stackoverflow

• Apache Daemon will run your Java program as Linux daemon or WinNT Service.

• You could try Java Service Wrapper, the community edition is free and meets your needs.

• I prefer the nohup command. The blog post says there are better ways, but I don't think they're enough better.

• That depends. If it's just a one-time thing, I want to daemonize it and then go home, but usually I wait for the results, I might do:

  nohup java com.me.MyProgram &
  

  at the command line. To kill it cleanly, you have a lot of options. You might have a listener for SIGKILL, or listen on a port and shutdown when a connection is made, periodically check a file. Difference approaches have different weaknesses. If it's for use in production, I'd give it more thought, and probably throw a script into /etc/init.d that nohups it, and have a more sophisticated shutdown, such as what tomcat has.

• I frequently find myself writing scripts or command lines which essentially look like this, if I want to:

  1. Run a program that is immune to sighups
  2. That is completely disconnected from the shell which spawns it, and
  3. Produces a log file from stderr and stdout the contents of which are displayed as well, but
  4. Allows me to stop viewing the log in progress and do other stuff without disrupting the running process

  Enjoy.

  nohup java com.me.MyProgram </dev/null 2>&1 | tee logfile.log &

• If you can't rely on Java Service Wrapper cited above (for instance, if you are running on Ubuntu, which has no packaged version of SW) you probably want to do it the old fashioned way: have your program write its PID in /var/run/$progname.pid, and write a standard SysV init script (use for instance the one for ntpd as an example, it's simple) around it. Preferably, make it LSB-compliant, too.

  Essentially, the start function tests if the program is already running (by testing if /var/run/$progname.pid exists, and the contents of that file is the PID of a running process), and if not run

  logfile=/var/log/$progname.log
  pidfile=/var/run/$progname.pid
  nohup java -Dpidfile=$pidfile $jopts $mainClass </dev/null > $logfile 2>&1
  

  The stop function checks on /var/run/$progname.pid, tests if that file is the PID of a running process, verifies that it is a Java VM (so as not to kill a process that simply reused the PID from a dead instance of my Java daemon) and then kills that process.

  When called, my main() method will start by writing its PID in the file defined in System.getProperty("pidfile").

  One major hurdle, though: in Java, there is no simple and standard way to get the PID of the process the JVM runs in.

  Here is what I have come up with:

  private static String getPid() {
      File proc_self = new File("/proc/self");
      if(proc_self.exists()) try {
          return proc_self.getCanonicalFile().getName();
      }
      catch(Exception e) {
          /// Continue on fall-back
      }
      File bash = new File("/bin/bash");
      if(bash.exists()) {
          ProcessBuilder pb = new ProcessBuilder("/bin/bash","-c","echo $PPID");
          try {
              Process p = pb.start();
              BufferedReader rd = new BufferedReader(new InputStreamReader(p.getInputStream()));
              return rd.readLine();
          }
          catch(IOException e) {
              return String.valueOf(Thread.currentThread().getId());
          }
      }
      // This is a cop-out to return something when we don't have BASH
      return String.valueOf(Thread.currentThread().getId());
  }
  

  David Rabinowitz : No need for the Java to write the PID, the script can do it as well (echo $! > /var/run/my.pid) Also, since usually only root can write to /var/run you can have the shell script running as root and the daemon run as another user.

  Varkhan : Except you can't change uid or euid in java, so you have to do it from the shell, with sudo... it's a bit of a pain if you ask me. It's easier to have /var/run and var/log writable to the user you run as...

  Varkhan : Also, the rationale for having Java write the pid file / lock file is to have a mean to know whether the initialization phase of the daemon completed successfully (by writing at the end of that phase).

• This question is about daemonizing an arbitrary program (not java-specific) so some of the answers may apply to your case:

  http://stackoverflow.com/questions/525247/how-do-i-daemonize

• If you like new stuff, you can try out Akuma. For (little) info see also Kohsuke Kawaguchi's Blog.