Alcune app della GUI si avviano in modo pulito tramite la riga di comando del Terminale, ma altre no e fanno in modo che il Terminale attenda il termine dell'app. Anche allora, alcuni non "rilasciano" la riga di comando.

Il misterioso &suffisso e commerciale sembra che il terminale metta il processo in secondo piano (ma non sono sicuro di cosa accada lì).

Esiste un modo per avviare un'app tramite il Terminale in modo che non vi sia alcun effetto "blocco", proprio come l'avvio di qualcosa tramite Alt+ F2?

Vorrei che la riga di comando fosse di nuovo disponibile immediatamente, senza che ci fosse ancora qualcosa in background e la stampa nel terminale.

Nel caso di Gedit, ne tengo sempre aperta una copia. Finché si dispone di una copia esistente, l'avvio delle geditchiamate dal terminale e la chiusura del terminale non uccideranno Gedit.

Per altre cose, anche quello che altre persone hanno detto avrebbe funzionato. Sono un fan di nohup... Ma se hai bisogno di un terminale puoi staccarlo ma poi ricollegarti, vuoi guardare screen.

1. Eseguilo in un terminale e quindi esegui qualcosa che continua a spingere l'output. Uso il server di sviluppo di Django, ma irssio watch uptimesarei anche buoni esempi.
2. Uccidi il terminale e iniziane uno nuovo.
3. Corri screen -re BOOM, sei tornato.

screenè molto più grande di quello e puoi combinarlo byobuper una migliore esperienza terminale. Leggi in giro.

Supponiamo che geditsia il programma che si desidera eseguire distaccato (alias "disnown", "disentangled", "disaccoppiato"). Esistono diversi modi a seconda di cosa si desidera fare esattamente:

Programma già in esecuzione

rinnegare:

disown -hè la strada da percorrere se vuoi farlo con un programma già in esecuzione (cioè se ti sei dimenticato di nohupfarlo). Devi prima interromperlo usando Ctrl+ Z. Quindi è possibile inserire in background utilizzando bg [jobId](ad esempio bg 1). Si ottiene un elenco di lavori in esecuzione con il loro jobId utilizzando jobs. Dopodiché puoi separarlo dal terminale usando disown -h %[jobId]. Esempio di sessione terminale:

$ gedit 
^Z
[1]+  Stopped                 gedit
$ jobs
[1]+  Stopped                 gedit
$ bg 1
[1]+ gedit &
$ disown -h %1
$ exit

Il programma non è ancora iniziato

nohup

nohupnon è sempre presente su tutte le macchine. Se sai di voler disaccoppiare in anticipo, utilizzeresti:

nohup gedit &

Forse si vuole reindirizzare l'output della shell come bene e il programma di una sorgente di ingresso pseudo, così: nohup ./myprogram > foo.out 2> bar.err < /dev/null &. Si desidera reindirizzare l'output per non essere infastidito da esso o utilizzarlo in un secondo momento. L'input null può aiutare a prevenire i rallentamenti in ssh e tali.

subshell:

Puoi ottenere un effetto simile con

$ (geany >/dev/null 2>&1 &)

Le parentesi aprono una nuova subshell per eseguire gedit. >/dev/null 2>&1Reindirizza l'output della shell verso il nulla (sopprimendo l'output). E &alla fine mette il processo in background.

Multiplazione terminale

Anche il multiplexing terminale tramite schermo o byobu . Fondamentalmente si esegue il programma in un terminale a sé stante. Posso davvero consigliare Byobu anche per altri motivi. Di seguito è riportato un elenco di scorciatoie boybu che potrebbero tornare utili per i tuoi primi passi:

Utile:

• F2 Crea una nuova finestra
• F3 Passa alla finestra successiva
• F4 Passa alla finestra precedente
• F6 Staccare dalla sessione e disconnettersi
• Shift-F6 Staccare dalla sessione, ma non disconnettersi
• F7 Entra in modalità scorrimento / ricerca
• Ctrl-F5 Ricollegare eventuali socket o agenti SSH / GPG

Meno utile:

• Shift-F2 Dividi lo schermo in orizzontale
• Ctrl-F2 Dividi lo schermo in verticale
• Shift-F3 Sposta lo stato attivo sulla divisione successiva
• Shift-F4 Sposta lo stato attivo sulla divisione precedente
• Shift-F5 Comprimi tutte le divisioni
• F5 Aggiorna tutte le notifiche di stato
• F8 Rinomina la finestra corrente
• F9 Avvia il menu di configurazione di Byobu
• F12 Tasto Escape dello schermo GNU
• Alt-Pageup Scorri indietro nella cronologia di questa finestra
• Alt-Pagedown Scorri in avanti attraverso la cronologia di questa finestra
• Ctrl-a-! Attiva o disattiva tutte le combinazioni di tasti di Byobu

Il demone "at" e altri

atè un piccolo strumento utile per eseguire un comando ad un orario programmato. Può essere 'usato in modo improprio' per staccare un comando dalla shell:

echo './myprogram myoption1 myoption2' | at now

Inoltre puoi esaminare setside start-stop-daemon, ma gli altri metodi dovrebbero essere sufficienti.

La misteriosa e commerciale "&" suffisso sembra far sì che il terminale metta il processo in secondo piano ... (ma non sono sicuro di cosa accada lì).

Lo fa ed è spesso quello che vuoi. Se dimentichi di usare &, puoi sospendere il programma con ctrl-z, quindi posizionarlo in background con il comando bg - e continuare a usare quella shell.

Il processo 'stdin, stdout e stderr sono ancora connessi al terminale; puoi reindirizzare quelli da / a / dev / null o qualsiasi altro file (ad es. salvare un registro di output da qualche parte), come desiderato:

some-program </dev/null &>/dev/null &
# &>file is bash for 1>file 2>&1

Puoi vedere il processo nei lavori, riportarlo in primo piano (comando fg) e inviarlo segnali (comando kill).

Alcuni programmi grafici si staccano dal terminale; in tal caso, quando esegui il comando "normalmente" noterai che avvia il programma grafico ed "esce".

Ecco uno script breve , puoi inserirlo in ~ / bin , che ho chiamato runbg:

#!/bin/bash
[ $# -eq 0 ] && {  # $# is number of args
  echo "$(basename $0): missing command" >&2
  exit 1
}
prog="$(which "$1")"  # see below
[ -z "$prog" ] && {
  echo "$(basename $0): unknown command: $1" >&2
  exit 1
}
shift  # remove $1, now $prog, from args
tty -s && exec </dev/null      # if stdin is a terminal, redirect from null
tty -s <&1 && exec >/dev/null  # if stdout is a terminal, redirect to null
tty -s <&2 && exec 2>&1        # stderr to stdout (which might not be null)
"$prog" "$@" &  # $@ is all args

Cerco il programma ($ prog) prima di reindirizzare in modo da poter segnalare errori nel localizzarlo. Eseguilo come "runbg your-command args ..."; puoi comunque reindirizzare stdout / err su un file se devi salvare l'output da qualche parte.

Ad eccezione dei reindirizzamenti e della gestione degli errori, ciò equivale alla risposta di Htorque .

Per avviare un'applicazione e staccarla dal terminale avviato, utilizzare & !.

firefox &!

Uso nohup

nohup è un programma che esegue un determinato comando con segnali di riaggancio ignorati, in modo che il comando possa continuare a essere eseguito in background al termine del processo padre. Vedi la manpage

Per esempio:

nohup gedit something

Apri il terminale, digita schermo , digita il comando che vuoi eseguire, chiudi il terminale. Il programma dovrebbe continuare a funzionare nella sessione GNU Screen .

Questo ha funzionato per me:

$ (nohup gedit 2>/dev/null &)

xdg-open

Dai un'occhiata a questa utility per tutti gli usi: https://linux.die.net/man/1/xdg-open

Questo aprirà una posizione relativa nel tuo file manager.

 $ xdg-open .

Questo aprirà un file pdf in un lettore pdf.

 $ xdg-open foo.pdf

Puoi anche fornire URL web

$ xdg-open www.google.com

Come molte persone hanno capito, nohup è la cosa da considerare. Ma le immagini fisse nohup rimangono aperte sul terminale e mostrano l'attività del programma sul terminale che è irritante. Dopo puoi semplicemente chiudere il terminale per evitarlo. Ho scoperto una soluzione molto semplice che utilizzo.

nohup gedit & exit

E questo è tutto. Apre gedit e chiude il terminale all'avvio di gedit. Poiché gedit non è associato al terminale ora, rimane attivo.

Funziona anche all'interno di uno script (come gli alias, il trailer "&" normalmente non è consentito negli script perché non sono interattivi):

bash -i >/dev/null 2>&1 <<<'nohup gedit &'

Questo ha funzionato per me:

$ (some-program &) &>/dev/null

# Examples:
$ (gedit &) &>/dev/null
$ (google-chrome &) &>/dev/null