Come avviare i programmi linux della GUI dalla riga di comando, ma separati dalla riga di comando?

Ho cercato prima questo, ma non sono mai stato in grado di trovare una risposta.

In Windows, se ho una finestra della console aperta, digitare winminee premere Invio, apparirà Minesweeper, completamente separato dal programma cmd. L'istanza di Minesweeper non è legata al prompt dei comandi in alcun modo che io conosca, con l'eccezione del genitore di Minesweeper impostato su quell'istanza del prompt dei comandi. È diverso in Linux, tuttavia.

In Linux, se ho una finestra della console aperta, digitare emacse premere Invio, Emacs si aprirà, ma sembra legato alla riga di comando. In particolare, sembra che non posso più usare la riga di comando fino a quando quell'istanza di Emacs non viene chiusa. C'è un modo per replicare il comportamento di Windows in Linux?

Grazie!

In bash, detachè un built-in, utilizzato come segue:

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

In zsh, è possibile eseguire lo sfondo e il distacco in un'unica operazione:

emacs &|

Aggiungi &alla riga di comando:

emacs &

Questo metterà emacs in background e ti consentirà di continuare a utilizzare il tuo terminale.

Nota che questo lascerà comunque emacs come sottoprocesso del tuo terminale e quando esci dal terminale uscirà anche emacs. Per evitare ciò, digitare:

(emacs &)

Le parentesi indicano al terminale di staccare il processo emacs dal terminale.

Tuttavia, sul terminale verranno visualizzati i messaggi stdout e stderr del programma. Per evitare ciò, utilizzare:

(emacs &> /dev/null &)

Usa nohup. Come questo:nohup amarok &

Spero che sia di aiuto.

Ho pubblicato una risposta a un vecchio thread di argomento simile con risposte da varie fonti. Di seguito è una copia di quella risposta adattata per questa discussione.

I seguenti lavori:

$ (gui_app &> /dev/null &)

Questa è la risposta di Nathan Fellman più il reindirizzamento.

"&> / dev / null" reindirizza sia stdout che stderr sul dispositivo null. L'ultima e commerciale fa eseguire il processo in background. Le parentesi attorno al comando faranno funzionare "gui_app" in una subshell.

In questo modo si scollegherà il processo "gui_app" dalla console da cui si esegue questo comando. Quindi, anche se si chiude l'emulatore di terminale parent della finestra in esecuzione, "gui_app" non si chiuderà. Ho eseguito questo quindi ho guardato l'albero dei processi con il comando "pstree" e ho trovato un'applicazione avviata in questo modo diventerà un processo figlio di "init".

Per esempio,

$ gui_app &> /dev/null &

eseguirà l'applicazione in background, ma diventerà un processo figlio del processo della console e terminerà quando si chiude il terminale. (Sebbene uscire dal terminale tramite bash usando il comando exit o Ctrl-D consentirà a bash di ripulire consegnando il processo in background a init.)

"nohup" funziona come ha suggerito NawaMan, ma per impostazione predefinita reindirizza l'output e l'errore su un file. Come ha risposto JeffG, il comando "disown" (se disponibile nella shell) può staccare il processo dal terminale dopo aver avviato un processo in background:

$ gui_app &
$ disown

(A proposito, tutto ciò vale per bash. Sono sicuro che altre shell hanno altri metodi / sintassi per farlo.)

Alcuni riferimenti: Disowning Processes (UNIX Power Tools)

Se si tratta di una semplice chiamata a un'applicazione della GUI - senza opzioni complicate e simili - sembra che anche usare un launcher come "gmrun" o dmenu (avviso: audio forte) sia una buona opzione. Associlo a una combinazione di tasti. Non uso ancora un launcher ma ho provato quei due.

NOTA: CarlF nei commenti degli altri thread riporta che le app della GUI avviate tramite il metodo "gui_app &" non si chiudono quando esce dal terminale principale. Penso che stessimo chiudendo il terminal in diversi modi. Stavo chiudendo la finestra in cui era in esecuzione l'emulatore di terminale. Penso che potrebbe essere uscito dall'emulatore di terminale attraverso la shell (comando di uscita o Ctrl-D). Ho provato questo e ho visto che uscire da bash non ferma la GUI avviata come processo in background del terminale, come dice CarlF. Sembra che bash stia iniziando i processi in background quando gli viene data la possibilità di ripulire. In realtà, questo deve essere il meccanismo mediante il quale il processo in background avviato in una subshell viene passato a init.

util-linux include uno strumento chiamato setsid che sostanzialmente fa ciò che fa staccare:

$ setsid someprogram

Questo verrà eseguito someprogramin una nuova sessione.

Prova a digitare xemacs &per aprire XEmacs in background.

Si prega di non fare riferimento a questo come "emulazione del comportamento di Windows". Ahia.

Potresti anche:

• Apri un nuovo terminale
• Usa Alt + F2 o il tuo gestore di finestre per avviare il programma, invece di utilizzare il terminale
• Usa schermo GNU

Ho inserito il seguente codice in un file di script eseguibile chiamato "sbg" per "sfondo silenzioso". Fa tutto il necessario per disconnettere completamente il programma avviato dalla shell: reindirizza stdin, stdout e stderr da / a /dev/null, ignora i blocchi, gira in background e si stacca.

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

Quindi puoi semplicemente farlo sbg emacs. È inoltre possibile passare alcun argomento che si desidera: sbg emacs --daemon FILE1 FILE2.

command &

Metti una e commerciale dopo il comando.

se stai usando bash, puoi rinnegare il processo:

% firefox &
% disown 

Puoi usare questa linea singola:

$ emacs & disown

Come dicono le altre risposte, puoi usare quanto segue:

$ emacs &

Se si dimentica il &pensiero, basta premere Ctrl-zquindi utilizzare bg:

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

Cordiali saluti: Ctrl-zinterrompe il processo di emacs e bginvia in background.

semplicemente usando &come in $ x &lascia il processo attaccato al terminale ho preso un piccolo programma chiamato detach http://inglorion.net/software/detach/ che ho aliasato in dquanto è un po 'come nohupma non lascia un file di registro i usalo per staccare mupdf :d mupdf x.pdf

Metti questo nel tuo ~/.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

Ora non devi ricordare quali programmi sono X11 e fare manipolazioni speciali per loro perché si staccano automaticamente. Nota che setsidè meglio che nohupl'ultimo blocchi il segnale HUP che non è quello che ti serve.

PS Ora sei già winminein Linux.