Como se livrar do processo recém-iniciado

Eu quero iniciar o processo (por exemplo, myCommand) e obter o seu pid (para permitir matá-lo mais tarde).

Eu tentei ps e filtrar por nome, mas não consigo distinguir processo por nomes

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

Porque nomes de processos não são exclusivos.

Eu posso executar o processo por:

myCommand &

Descobri que posso obter esse PID:

echo $!

Existe alguma solução mais simples?

Eu ficaria feliz em executar o myCommand e obter seu PID como resultado de um comando de linha.

O que pode ser mais simples do que echo $!? Como uma linha:

myCommand & echo $!

Embrulhe o comando em um pequeno script

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

Você pode usar sh -ce execobter o PID do comando antes mesmo de ele ser executado.

Para começar myCommand, para que seu PID seja impresso antes de começar a ser executado, você pode usar:

sh -c 'echo $$; exec myCommand'

Como funciona:

Isso inicia um novo shell, imprime o PID desse shell e, em seguida, usa o execbuilt-in para substituir o shell pelo seu comando, garantindo que ele tenha o mesmo PID. Quando seu shell executa um comando com o execbuilt-in, seu shell está realmente se tornando esse comando , em vez do comportamento mais comum de criar uma nova cópia de si mesmo, que possui seu próprio PID separado e que se torna o comando.

Acho que isso é muito mais simples do que as alternativas que envolvem execução assíncrona (com &), controle de tarefas ou pesquisa com ps. Essas abordagens são boas, mas, a menos que você tenha um motivo específico para usá-las - por exemplo, talvez o comando já esteja em execução; nesse caso, procurar por seu PID ou usar o controle de tarefas faria sentido - sugiro considerar isso primeiro. (E eu certamente não consideraria escrever um script complexo ou outro programa para conseguir isso).

Esta resposta inclui um exemplo dessa técnica.

Partes desse comando podem ocasionalmente ser omitidas, mas não geralmente.

Mesmo que o shell que você está usando seja do estilo Bourne e, portanto, ofereça suporte ao execincorporado com essas semânticas, geralmente você não deve evitar o uso sh -c(ou equivalente) para criar um novo processo de shell separado para esse fim, porque:

• Depois que o shell se torna myCommand, não há shell esperando para executar comandos subseqüentes. sh -c 'echo $$; exec myCommand; foonão seria capaz de tentar executar foodepois de se substituir por myCommand. A menos que você esteja escrevendo um script que execute isso como seu último comando, você não pode simplesmente usar echo $$; exec myCommandem um shell em que esteja executando outros comandos.
• Você não pode usar um subshell para isso. (echo $$; exec myCommand)pode ser sintaticamente melhor do que sh -c 'echo $$; exec myCommand', mas quando você executa o $$interior ( ), ele fornece o PID do shell pai, não do subshell em si. Mas é o PID do subshell que será o PID do novo comando. Alguns shells fornecem seus próprios mecanismos não portáteis para localizar o PID do subshell, que você pode usar para isso. Em particular, no Bash 4 , (echo $BASHPID; exec myCommand)funciona.

Por fim, observe que alguns shells executam uma otimização onde executam um comando como se fossem exec(ou seja, renunciam primeiro à bifurcação) quando se sabe que o shell não precisará fazer nada posteriormente. Alguns shells tentam fazer isso a qualquer momento, sendo o último comando a ser executado, enquanto outros o fazem apenas quando não há outros comandos antes ou depois do comando, e outros não o fazem. O efeito é que, se você esquecer de escrever exece usar sh -c 'echo $$; myCommand', ele às vezes fornecerá o PID correto em alguns sistemas com alguns shells. Eu recomendo que nunca confie em tal comportamento e, em vez disso, sempre inclua execquando é isso que você precisa.

Não conheço nenhuma solução mais simples, mas não estou usando $! bom o bastante? Você sempre pode atribuir o valor a alguma outra variável, se precisar mais tarde, como dito por outras pessoas.

Como uma observação lateral, em vez de usar o ps do ps, você pode usar pgrepor pidof.

use exec de um script bash depois de registrar o pid em um arquivo:

exemplo:

suponha que você tenha um script chamado "forever.sh" que deseja executar com args p1, p2, p3

código-fonte forever.sh:

#!/bin/sh

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

crie um reaper.sh:

#!/bin/sh

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

execute forever.sh através de reaper.sh:

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

forever.sh não faz nada além de registrar uma linha no syslog a cada 5 segundos

agora você tem o pid em /var/run/forever.sh.pid

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

e forever.sh está funcionando bem. syslog grep:

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

você pode vê-lo na tabela de processos:

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

No shell bash, uma alternativa ao $!pode ser o jobs -pbuilt-in. Em alguns casos, o !in $!é interpretado pelo shell antes (ou em vez de) da expansão da variável, levando a resultados inesperados.

Isso, por exemplo, não funcionará:

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

enquanto isso irá:

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

Você pode usar algo como:

$ myCommand ; pid=$!

Ou

$ myCommand && pid=$!

Os dois comandos podem ser articulações usando ;ou &&. No segundo caso, o pid será definido apenas se o primeiro comando for bem-sucedido. Você pode obter o ID do processo $pid.

Esta é uma resposta um tanto quanto improvável e provavelmente não funcionará para a maioria das pessoas. Também é um risco enorme para a segurança, então não faça isso, a menos que você tenha certeza de que estará seguro e que as entradas são higienizadas e ... bem, você entendeu.

Compile o pequeno programa C aqui em um binário chamado start(ou o que você quiser) e execute o programa como./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;
}

Para encurtar a história, isso imprimirá o PID e stdout, em seguida, carregará seu programa no processo. Ainda deve ter o mesmo PID.