Scenario / Questions

I want to start process (eg. myCommand) and get its pid (to allow to kill it later).

I tried ps and filter by name, but I can not distinguish process by names

myCommand
ps ux | awk '/<myCommand>/ {print $2}' 

Because processes names are not unique.

I can run process by:

myCommand &

I found that I can get this PID by:

echo $!

Is there any simpler solution?

I would be happy to execute myCommand and get its PID as a result of one line command.

Find below all possible solutions or suggestions for the above questions..

Suggestion: 1

What can be simpler than echo $!? As one line:

myCommand & echo $!

Suggestion: 2

Wrap the command in a small script

#!/bin/bash
yourcommand &
echo $! >/path/to/pid.file

Suggestion: 3

You can use sh -c and exec to get the command’s PID even before it runs.

To start myCommand, so that its PID is printed before it begins to run, you can use:

sh -c 'echo $$; exec myCommand'

How it works:

This starts a new shell, prints the PID of that shell, and then uses the exec builtin to replace the shell with your command, ensuring it has the same PID. When your shell runs a command with the exec builtin, your shell is actually becoming that command, rather than the more common behavior of forking a new copy of itself, which has its own separate PID and which then becomes the command.

I find this to be much simpler than alternatives involving asynchronous execution (with &), job control, or searching with ps. Those approaches are fine, but unless you have a specific reason to use them–for example, perhaps the command is already running, in which case searching for its PID or using job control would make sense–I suggest considering this way first. (And I would certainly not consider writing a complex script or other program to achieve this).

This answer includes an example of this technique.


Parts of that command could occasionally be omitted, but not usually.

Even if the shell you’re using is a Bourne-style and thus supports the exec builtin with these semantics, you generally shouldn’t try to avoid using sh -c (or equivalent) to create a new, separate shell process for this purpose, because:

  • Once the shell has become myCommand, there’s no shell waiting to run subsequent commands. sh -c 'echo $$; exec myCommand; foo would not be able to attempt to run foo after replacing itself with myCommand. Unless you’re writing a script that runs this as its last command, you can’t just use echo $$; exec myCommand in a shell where you are running other commands.
  • You cannot use a subshell for this. (echo $$; exec myCommand) may be syntactically nicer than sh -c 'echo $$; exec myCommand', but when you run $$ inside ( ), it gives the PID of the parent shell, not of the subshell itself. But it is the subshell’s PID that will be the PID of the new command. Some shells provide their own non-portable mechanisms for finding the subshell’s PID, which you could use for this. In particular, in Bash 4, (echo $BASHPID; exec myCommand) does work.

Finally, note that some shells will perform an optimization where they run a command as if by exec (i.e., they forgo forking first) when it is known that the shell will not need to do anything afterward. Some shells try to do this anytime it is the last command to be run, while others will only do it when there are no other commands before or after the command, and others will not do it at all. The effect is that if your forget to write exec and just use sh -c 'echo $$; myCommand' then it will sometimes give you the right PID on some systems with some shells. I recommend against ever relying on such behavior, and instead always including exec when that’s what you need.

Suggestion: 4

I do not know of any simpler solution, but isn’t using $! good enough? You can always assign the value to some other variable if you need it later, as said by others.

As a side note, instead of piping from ps you could use pgrep or pidof.

Suggestion: 5

use exec from a bash script after registering the pid to a file:

example:

suppose you have a script named “forever.sh” that you want to run with args p1,p2,p3

forever.sh sourcecode:

#!/bin/sh

while [ 1 -lt 2 ] ; do
    logger "$0 running with parameters \"$@\""
    sleep 5
done

create a reaper.sh:

#!/bin/sh

echo $$ > /var/run/$1.pid
exec "$@"

run forever.sh through reaper.sh:

./reaper.sh ./forever.sh p1 p2 p3 p4 &

forever.sh does nothing more than logging a line to syslog each 5 seconds

you now have the pid in /var/run/forever.sh.pid

cat /var/run/forever.sh.pid 
5780

and forever.sh is running aok. syslog grep:

Nov 24 16:07:17 pinkpony cia: ./forever.sh running with parameters "p1 p2 p3 p4"

you can see it in the process table:

ps axuwww|grep 'forever.sh p1' |grep -v grep
root      5780  0.0  0.0   4148   624 pts/7    S    16:07   0:00 /bin/sh ./forever.sh p1 p2 p3 p4

Suggestion: 6

In the bash shell an alternative to $! might be the jobs -p built-in. In some cases the ! in $! gets interpreted by the shell before (or instead of) the variable expansion, leading to unexpected results.

This, for example, won’t work:

((yourcommand) & echo $! >/var/run/pidfile)

while this will:

((yourcommand) & jobs -p >/var/run/pidfile)

Suggestion: 7

You can use something like:

$ myCommand ; pid=$!

Or

$ myCommand && pid=$!

The two commands can be joints using ; or &&. In the second case, the pid will be set only if the first command succeeds. You can get the process id from $pid.

Suggestion: 8

This is a bit of a hack-y answer and won’t likely work for most people. It’s also a huge security risk methinks, so don’t do it unless you’re sure you’ll be safe and the inputs are sanitized and…well, you get the idea.

Compile the little C program here into a binary called start (or whatever you want), then run your program as ./start your-program-here arg0 arg1 arg2 ...

#include <stdio.h>
#include <stdlib.h>
#include <sys/types.h>
#include <unistd.h>

int main(int argc, char **argv)
{
    if (argc >= 2)
    {
        printf("%lu\n", (long unsigned) getpid());
        if (execvp(argv[1], &argv[1]) < 0)
        {
            perror(NULL);
            return 127;
        }
    }
    return 0;
}

Long story short, this will print the PID to stdout, then load your program into the process. It should still have the same PID.