Como iniciar programas GUI linux a partir da linha de comando, mas separados da linha de comando?

Question

Eu já pesquisei isso antes, mas nunca consegui encontrar uma resposta.

No Windows, se eu tiver uma janela de console aberta, digite winmine e pressione enter, o Campo Minado será exibido, completamente separado do programa cmd. A instância de Campo Minado não está vinculada ao prompt de comando de qualquer maneira que eu saiba, com exceção do pai do Campo Minado sendo definido para aquela instância do prompt de comando. É diferente no Linux, no entanto.

No Linux, se eu tiver uma janela de console aberta, digite emacs e pressione enter, o Emacs será aberto, mas parece estar vinculado à linha de comando. Especificamente, parece que não posso mais usar a linha de comando até que essa instância do Emacs seja fechada. Existe uma maneira de replicar o comportamento do Windows no Linux?

Obrigado!

    

Answer 1

Em bash , detach é um built-in, usado da seguinte forma:

emacs &
detach %+ # or % + the number in brackets printed after the above

Em zsh , você pode destacar e destacar em uma única operação:

emacs &|

    

Answer 2

Anexe o & à linha de comando:

emacs &

Isso colocará o emacs em segundo plano e permitirá que você continue usando seu terminal.

Observe que isso ainda deixará o emacs como um subprocesso do seu terminal e, quando você sair do terminal, ele também sairá do emacs. Para evitar isso, digite:

(emacs &)

Os parênteses dizem ao terminal para separar o processo do emacs do terminal.

Ainda assim, as mensagens stdout e stderr do programa serão exibidas no terminal. Para evitar isso, use:

(emacs &> /dev/null &)

    

Answer 3

Use nohup . Assim: nohup amarok &

Espero que isso ajude.

    

Answer 4

Eu postei uma resposta para um tópico mais antigo de um tópico semelhante com respostas de várias fontes. A seguir, uma cópia dessa resposta adaptada para este tópico.

Seguintes trabalhos:

$ (gui_app &> /dev/null &)

Esta é a resposta de Nathan Fellman mais o redirecionamento.

"& > / dev / null" redireciona stdout e stderr para o dispositivo nulo. O último e comercial torna o processo executado em segundo plano. Os parênteses ao redor do comando farão com que seu "gui_app" seja executado em uma subcamada.

Isso desanexará o processo "gui_app" do console em que você executa esse comando. Portanto, mesmo se você fechar o emulador de terminal pai da janela, o "gui_app" não será fechado. Eu corri isso, em seguida, olhei para a árvore de processo com o comando "pstree" e encontrei um aplicativo iniciado dessa forma se tornará o processo filho para "init".

Por exemplo,

$ gui_app &> /dev/null &

executará o aplicativo em segundo plano, mas se tornará um processo secundário do processo do console e terminará quando você fechar o terminal. (Embora sair do terminal através do bash usando o comando exit ou Ctrl-D, o bash será limpo, entregando o processo de segundo plano ao init.)

"nohup" funciona como o NawaMan sugeriu, mas isso redireciona a saída & erro para um arquivo por padrão. Como o JeffG respondeu, o comando "disown" (se disponível no shell) pode desanexar o processo do terminal depois que você iniciou um processo em segundo plano:

$ gui_app &
$ disown

(BTW tudo isso se aplica ao bash. Tenho certeza de que outros shells têm outros métodos / sintaxe para fazer isso.)

Alguma referência: Processos de rejeição (Ferramentas elétricas do UNIX)

Se é uma simples chamada para um aplicativo GUI - sem opções complicadas e tal - parece que é possível usar um iniciador como "gmrun" ou dmenu (aviso: áudio alto) também é uma boa opção. Vinculá-lo a uma combinação de teclas. Eu não uso um lançador ainda, mas tentei os dois.

NOTA: O CarlF nos comentários de o outro segmento relata os aplicativos GUI iniciados por meio de "gui_app &" método não fecha quando ele sai do terminal pai. Acho que estávamos fechando o terminal de maneiras diferentes. Eu estava fechando a janela em que o emulador de terminal estava sendo executado. Acho que ele pode ter saído do emulador de terminal por meio do shell (comando de saída ou Ctrl-D). Eu testei isso e vi que sair através do bash não para a GUI iniciada como processo em segundo plano do terminal, como diz CarlF. Parece que o bash entrega os processos em segundo plano ao init quando é dada a chance de limpar. De fato, este deve ser o mecanismo pelo qual o processo em segundo plano iniciado em uma subcamada é transferido para o init.

    

Answer 5

O util-linux inclui uma ferramenta chamada setsid que basicamente faz o que o detach faz:

$ setsid someprogram

Isso executará someprogram em uma nova sessão.

    

Answer 6

Tente digitar xemacs & para abrir o XEmacs em segundo plano.

Por favor, não se refira a isso como "emulando o comportamento do Windows". Ai.

Você também pode:

• Abra um novo terminal
• Use Alt + F2 ou o gerenciador de janelas para iniciar o programa, em vez de usar o terminal
• Use a tela GNU

Answer 7

Eu coloquei o seguinte código em um arquivo de script executável chamado "sbg" para "fundo silencioso". Ele faz todas as coisas necessárias para desconectar completamente o programa que está sendo iniciado do shell: redireciona stdin, stdout e stderr de / para /dev/null , ignora os desligamentos, executa em segundo plano e desanexa.

#!/bin/bash
nohup "$@" &>/dev/null & disown %%

Então você pode fazer apenas sbg emacs . Você também pode passar qualquer argumento que quiser: sbg emacs --daemon FILE1 FILE2 .

    

Answer 8

command &

Coloque um e comercial após o comando.

    

Answer 9

se você estiver usando o bash, você pode ignorar o processo:

% firefox &
% disown 

    

Answer 10

Você pode usar esta linha única:

$ emacs & disown

    

Answer 11

Como as outras respostas dizem, você pode usar o seguinte:

$ emacs &

Se você esquecer o & , pressione Ctrl-z e use bg :

[1]+  Stopped                 emacs
$ bg
[1]+ emacs &
$

FYI: Ctrl-z interrompe o processo do emacs e bg envia para segundo plano.

    

Answer 12

usando apenas & como em $ x & deixa o processo anexado ao terminal eu peguei um pequeno programa chamado detach link que eu aliasse como d é um pouco como nohup mas não deixa para trás um arquivo de log eu uso ele para destacar mupdf : d mupdf x.pdf

    

Answer 13

Coloque isso no seu ~/.bashrc :

debug_trap_skip()
{
    local cmd_type=$(type -t "$1")

    # Empty cmd_type is for inexistent command or variable definition, exclude them
    # and shell builtins except echo, set and env:
    [[ -z "$cmd_type" || "$cmd_type" = builtin && "$1" != echo && "$1" != set && "$1" != env ]] &&
        return 0

    return 1
}

debug_trap_x11()
{
    if ldd 'which $1'|grep -q libX11
    then
        setsid "$@"
        return 0
    fi
    return 1
}

debug_trap()
{
    [[ -n "$COMP_LINE" ]] && return  # do nothing if completing
    [[ "$BASH_COMMAND" = "$PROMPT_COMMAND" ]] && return
    debug_trap_skip $BASH_COMMAND && return 0
    debug_trap_x11 $BASH_COMMAND && return 1

    return 0
}

shopt -s extdebug
trap debug_trap DEBUG

Agora você não precisa se lembrar de quais programas são X11 e fazer manipulações especiais para eles, pois eles serão desanexados automaticamente. Observe que setsid é melhor que nohup porque o último bloqueia o sinal HUP, que não é o que você precisa.

P.S. Agora você está com winmine no Linux.