Encontrar um processo tentando fazer algum tipo de reconhecimento de padrões nos argumentos do processo (como pgrep "mysqld") é uma estratégia que está condenada a falhar mais cedo ou mais tarde. E se tiveres dois mysqld a funcionar? Esquece essa abordagem. Você pode acertar temporariamente e pode funcionar por um ano ou dois, mas então algo acontece que você não pensou.

Só o ID do processo (pid) é verdadeiramente único.

Guarda sempre o pid quando lançares algo no fundo. In Bash isto pode ser feito com a variável Bash $!. Vais poupar-te tanto trabalho ao fazê-lo.

Como determinar se o processo está a correr (por pid)

Simplesmente faça:

ps -o pid= -p <pid>

Isto vai funcionar no Linux, BSD, Solaris, etc.

Outra estratégia seria testar o valor de saída do comando ps acima. Deve ser zero se o processo estiver em execução e não-zero se não estiver. o POSIX spec diz que ps deve sair >0 se ocorreu um erro, mas não está claro para mim o que constitui 'um erro'. Portanto, eu não estou pessoalmente usando essa estratégia, embora eu tenho certeza que ele vai funcionar também em todas as plataformas Unix/Linux.

Na maioria das distribuições Linux, você pode usar pidof(8).

Irá imprimir os ids do processo de todas as instâncias em execução de processos especificados, ou nada se não houver instâncias em execução.

$ pidof bash remmina
6148 6147 6144 5603 21598

Em outros Unices, pgrep ou uma combinação de ps e {[6] } irá alcançar a mesma coisa, como outros correctamente salientaram.

A forma mais simples é usar ps e grep:

command="httpd"
running=`ps ax | grep -v grep | grep $command | wc -l`
if [ running -gt 0 ]; then
    echo "Command is running"
else
    echo "Command is not running"
fi

Se o seu comando tiver alguns argumentos de comando, então Poderá também colocar mais 'grep cmd_arg1' após 'grep $command' para filtrar outros processos possíveis em que não esteja interessado.

Exemplo: mostra-me se algum processo java com argumento fornecido:

Está a correr

ps ax | grep -v grep | grep java | grep java.util.logging.config.file=logging.properties | wc -l

Isto deve funcionar na maioria dos Sabores do Unix, BSD e Linux:

PATH=/usr/ucb:${PATH} ps aux | grep httpd | grep -v grep

Testado em:

• SunOS 5.10 [daí o PATH=...]
• Linux 2. 6. 32 (CentOS)
• Linux 3. 0 (Ubuntu)
Darwin 11.2.0
• FreeBSD 9.0-estável
Red Hat Enterprise Linux es release 4
• Red Hat Enterprise Linux Server release 5

Apenas uma pequena adição: se adicionar a bandeira -c ao ps, não precisa de remover a linha que contém o processo grep com grep -v Depois. I. e.

ps acux | grep cron

É toda a tipagem de que necessita num sistema BSD-ish (isto inclui o MacOSX), pode deixar o {[[5]} de lado se necessitar de menos informação.

Num sistema onde a genética do nativo ps ponto de comando de volta para SysV, você usaria

ps -e |grep cron

Ou

ps -el |grep cron 

Para uma lista que contenha mais do que apenas pid e nome do processo. Claro que poderá seleccionar os campos específicos a imprimir com a opção -o <field,field,...>.

Juntando as várias sugestões, a versão mais limpa que consegui inventar (sem grep duvidoso que despoleta partes de palavras) é:

kill -0 $(pidof mysql) 2> /dev/null || echo "Mysql ain't runnin' message/actions"

O Kill-0 não mata o processo, mas verifica se existe e depois devolve verdadeiro, se não tiver o pidof no seu sistema, Guarde o pid quando iniciar o processo:

$ mysql &
$ echo $! > pid_stored

Depois no guião:

kill -0 $(cat pid_stored) 2> /dev/null || echo "Mysql ain't runnin' message/actions"

Uso {[[0]} mas não sei se está presente em qualquer plataforma...
Quem pode confirmar o OSX?

Você deve saber o PID do seu processo.

Quando o lançar, o seu PID será gravado na variável $!. Grava este PID num ficheiro.

Então terá de verificar se este PID corresponde a um processo em execução. Aqui está um script esqueleto completo:

FILE="/tmp/myapp.pid"

if [ -f $FILE ];
then
   PID=$(cat $FILE)
else
   PID=1
fi

ps -o pid= -p $PID
if [ $? -eq 0 ]; then
  echo "Process already running."  
else
  echo "Starting process."
  run_my_app &
  echo $! > $FILE
fi

Baseado na resposta de peterh. O truque para saber se um dado PID está em execução está na instrução ps -o pid= -p $PID.

Esta abordagem pode ser usada no caso de os comandos 'ps', 'pidof' e rest não estarem disponíveis. Eu pessoalmente uso procfs muito frequentemente em minhas ferramentas/scripts/programas.

   egrep -m1  "mysqld$|httpd$" /proc/[0-9]*/status | cut -d'/' -f3

1. -m1 - processo de paragem na primeira partida
2. "mysqld$ / httpd$" - grep irá corresponder às linhas que terminaram no mysqld ou no httpd
3. /proc/[0-9] * - bash irá corresponder à linha que começou com qualquer número {[[8]}
4. cortar-dividir a saída por separador ' / ' e extrair campo 3

ps -e -o args= | awk 'BEGIN{c=0}{
 if(!match($1,/^\[.*\]$/)){sub(".*/","",$1)} # Do not strip process names enclosed by square brackets.
 if($1==cmd){c++}
}END{print c}' cmd="chromium-browser"

Se isto imprime "0", o processo não está a correr. O comando assume que o caminho do processo não contém espaço de quebra. Eu não testei isso com processos suspensos ou processos zumbis.

Testado usando gwak como a alternativa awk no Linux.

Aqui está uma solução mais versátil com algum uso de exemplo:

#!/bin/sh
isProcessRunning() {
if [ "${1-}" = "-q" ]; then
 local quiet=1;
 shift
else
 local quiet=0;
fi
ps -e -o pid,args= | awk 'BEGIN{status=1}{
 name=$2
 if(name !~ /^\[.*\]$/){sub(".*/","",name)} # strip dirname, if process name is not enclosed by square brackets.
 if(name==cmd){status=0; if(q){exit}else{print $0}}
}END{exit status}' cmd="$1" q=$quiet
}

process='chromium-browser'

printf "Process \"${process}\" is "
if isProcessRunning -q "$process" 
 then printf "running.\n"
 else printf "not running.\n"; fi

printf "Listing of matching processes (PID and process name with command line arguments):\n"
isProcessRunning "$process"

• verifica o nome exacto do programa (primeiro argumento da função). a procura por " mysql "não irá corresponder à execução de"mysqld"
• procura argumentos do programa (segundo argumento da função)

Script:

#!/bin/bash

# $1 - cmd
# $2 - args
# return: 0 - no error, running; 1 - error, not running
function isRunning() {
    for i in $(pidof $1); do
        cat /proc/$i/cmdline | tr '\000' ' ' | grep -F -e "$2" 1>&2> /dev/null
        if [ $? -eq 0 ]; then
            return 0
        fi
    done
    return 1
}

isRunning java "-Djava.util.logging.config.file=logging.properties"
if [ $? -ne 0 ]; then
    echo "not running, starting..."
fi

process="$(pidof YOURPROCESSHERE|tr -d '\n')"
if [[ -z "${process// }" ]]; then
  echo "Process is not running."
else
  echo "Process is running."
fi

Explicação:

|tr -d '\n'

Isto remove o retorno de transporte criado pelo terminal. O resto pode ser explicado por este post.

A seguinte função shell, sendo apenas baseada em comandos e opções padrão POSIX deve funcionar na maioria (se não em qualquer) dos sistemas Unix e linux. :

isPidRunning() {
  cmd=`
    PATH=\`getconf PATH\` export PATH
    ps -e -o pid= -o comm= |
      awk '$2 ~ "^.*/'"$1"'$" || $2 ~ "^'"$1"'$" {print $1,$2}'
  `
  [ -n "$cmd" ] &&
    printf "%s is running\n%s\n\n" "$1" "$cmd" ||
    printf "%s is not running\n\n" $1
  [ -n "$cmd" ]
}

$ isPidRunning httpd
httpd is running
586 /usr/apache/bin/httpd
588 /usr/apache/bin/httpd

$ isPidRunning ksh
ksh is running
5230 ksh

$ isPidRunning bash
bash is not running

Note que vai sufocar quando passar o duvidoso nome de comando "0]" e também vai falhar em identificar processos com um espaço embutido em seus nomes.

Note também que a solução mais votada e aceite exige opções não Portáteis ps e usa gratuitamente uma concha que é, apesar da sua popularidade, não é garantido estar presente em todas as máquinas Unix / Linux(bash)