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

Eu procurei por isso antes, mas nunca consegui encontrar uma resposta.

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

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

Obrigado!

In bash, detaché um built-in, usado da seguinte maneira:

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

Em zsh, você pode colocar em segundo plano e desanexar em uma única operação:

emacs &|

Anexe &à 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, também sairá do emacs. Para evitar isso, digite:

(emacs &)

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

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

(emacs &> /dev/null &)

Use nohup. Como isso:nohup amarok &

Espero que isto ajude.

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

Trabalhos seguintes:

$ (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 faz com que o processo seja executado em segundo plano. Os parênteses ao redor do comando farão com que seu "gui_app" seja executado em um subshell.

Fazer isso desanexará o processo "gui_app" do console em que você executa este comando. Portanto, mesmo se você fechar o emulador de terminal pai da janela, o "gui_app" não será fechado. Eu executei isso, então olhei para a árvore do processo com o comando "pstree" e descobri que um aplicativo iniciado dessa maneira se tornará um processo filho para "init".

Por exemplo,

$ gui_app &> /dev/null &

executará o aplicativo em segundo plano, mas se tornará um processo filho do processo do console e será encerrado quando você fechar o terminal. (Embora sair do terminal através do bash usando o comando exit ou Ctrl-D permita que o bash seja limpo, envie o processo em segundo plano para o init.)

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

$ gui_app &
$ disown

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

Algumas referências: Disowning Processes (UNIX Power Tools)

Se for uma simples chamada para um aplicativo GUI - sem opções complicadas e outras coisas -, parece que usar um iniciador como "gmrun" ou dmenu (aviso: áudio alto) também é uma boa opção. Ligue-o a uma combinação de teclas. Ainda não uso um lançador, mas tentei esses dois.

OBSERVAÇÃO: CarlF nos comentários dos outros relatórios de encadeamento Os aplicativos GUI iniciados pelo método "gui_app &" não fecham quando ele sai do terminal pai. Eu acho que estávamos fechando o terminal de maneiras diferentes. Eu estava fechando a janela em que o emulador de terminal estava rodando. Acho que ele pode estar saindo do emulador de terminal através do shell (comando de saída ou Ctrl-D). Eu testei isso e vi que sair do bash não para a GUI iniciada como processo em segundo plano do terminal, como diz CarlF. Parece que bash retira processos em segundo plano para iniciar quando é dada a chance de limpar. De fato, esse deve ser o mecanismo pelo qual o processo em segundo plano iniciado em um subshell é enviado para o init.

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

$ setsid someprogram

Isso será executado someprogramem uma nova sessão.

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 seu gerenciador de janelas para iniciar o programa, em vez de usar o terminal
• Usar tela GNU

Coloquei o código a seguir 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 a partir do shell: redireciona stdin, stdout e stderr de / para /dev/null, ignora interrupções, executa em segundo plano e desanexa.

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

Então você pode apenas fazer sbg emacs. Você também pode passar quaisquer argumentos que você deseja: sbg emacs --daemon FILE1 FILE2.

command &

Coloque um e comercial após o comando.

se você estiver usando o bash, poderá negar o processo:

% firefox &
% disown 

Você pode usar esta única linha:

$ emacs & disown

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

$ emacs &

Se você se esquecer &, basta pressionar Ctrl-ze usar bg:

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

FYI: Ctrl-zinterrompe o processo emacs e bgenvia para segundo plano.

usando apenas &como $ x &deixa o processo anexado ao terminal, peguei um pequeno programa chamado detach http://inglorion.net/software/detach/, que eu tenho o apelido de dque é um pouco parecido, nohupmas não deixa para trás um arquivo de log use-o para desanexar o mupdf :d mupdf x.pdf

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 o X11 e fazer manipulações especiais para eles, porque serão desconectados automaticamente. Note que setsidé melhor do que nohupporque o último bloqueia o sinal HUP, que não é o que você precisa.

PS Agora você já está winmineno Linux.