Comment exécuter les commandes Linux en arrière-plan

L'exécution de commandes Linux en arrière-plan permet à l'utilisateur de continuer à exécuter d'autres tâches pendant que la commande est toujours en cours d'exécution. Pour exécuter une commande en arrière-plan, il y a plusieurs façons; L'une des méthodes simples est en ajoutant un ampères (&) à la fin de la ligne de commande.

Une fois qu'un processus est défini pour s'exécuter en arrière-plan, nous pouvons y accéder en utilisant le emplois commande. Cet article présente toutes les différentes façons d'exécuter une commande en arrière-plan.

La liste des différentes façons d'exécuter un processus d'arrière-plan est la suivante:

• • Ajout d'ampersand (&) signe
  • En utilisant la commande bg
  • En utilisant la commande noHup
  • Utilisation de la commande Diet
  • Utilisation de l'utilitaire TMUX

Voici le détail de toutes les méthodes pour exécuter un processus de fond:

1: Utilisation du signe AmperSand (&)

Dans Linux AmperSand (&) est un opérateur de shell qui envoie une commande en arrière-plan comme un processus distinct. En combinant AmperSand (&) sur une commande, il sera exécuté en tant que processus d'arrière-plan, permettant au shell de continuer à traiter d'autres commandes immédiatement.

Syntaxe pour un processus d'arrière-plan en utilisant un signe AmperSand:

$ [Command] &

Le symbole ampère et est toujours ajouté à la fin de la commande avec un seul espace entre "&" et dernier caractère de commande.

Par exemple, créez un processus de sommeil pendant 40 secondes.

$ Sleep 40

Comme nous pouvons le voir, le terminal exécute la commande de sommeil et ne nous permet pas d'effectuer une autre tâche.

Maintenant, appuyez sur "Ctrl + Z" Pour arrêter ce processus. Ensuite, nous exécuterons la même commande de sommeil cette fois, mais l'utilisation d'un opérateur d'ampère et de l'opérateur avec elle l'installera en arrière-plan.

$ sleep 40 &

Maintenant ce processus est en arrière-plan. Pour répertorier l'utilisation du processus en cours d'exécution:

$ Jobs -l

Tuez maintenant ce processus d'arrière-plan en utilisant:

$ kill -9 [job-id]

Par exemple, pour tuer l'utilisation actuelle du processus de sommeil:

$ kill -9 6149

Maintenant, le processus de sommeil est tué pour confirmer la liste du processus d'exécution de l'arrière-plan en utilisant.

$ Jobs -l

Voici un autre exemple d'utilisation & ampères Le signe est avec la commande gedit.

Par exemple, si nous ouvrons l'éditeur de texte GEDIT directement en utilisant le terminal, nous serons obligé d'utiliser le shell pour d'autres travaux, sinon nous devons d'abord arrêter le processus actuel.

$ gedit

L'utilisation de la commande ci-dessus ouvrira l'éditeur de texte qui l'ouvrira devant le terminal.

Mais après avoir utilisé «&» à la fin de la commande GEdit, le shell est libre à utiliser pour d'autres processus:

$ gedit &

2: Utilisation de la commande 'BG'

La commande BG est la deuxième façon d'exécuter des commandes en arrière-plan. Cette commande permet à l'utilisateur de continuer à travailler dans le terminal pendant que le processus s'exécute en arrière-plan, libérant le terminal pour d'autres tâches. La commande BG est utilisée pour un processus d'arrière-plan en cours d'exécution qui s'exécute même si l'utilisateur se connecte.

Comme un signe d'ampère et que nous n'avons pas à nous soucier de l'ajouter à la commande à chaque fois d'envoyer du texte BG au terminal. Il commencera à exécuter le processus en arrière-plan et libérera le terminal pour une utilisation future.

Par exemple, utilisons l'exemple précédent et envoyons la commande du sommeil en utilisant:

$ Sleep 40

Maintenant, le processus est en cours d'exécution et le terminal n'est pas disponible pour une utilisation. Pour utiliser la commande BG et envoyer ce processus en arrière-plan, nous devons d'abord arrêter le processus d'exécution actuel en appuyant sur "Ctrl + Z" et exécuter cette commande:

$ bg

Après avoir envoyé la commande BG, le processus de sommeil a commencé à se poursuivre en arrière-plan. Nous pouvons voir un ampère et "&" à la fin, indiquant que le processus actuel est en cours d'exécution.

Pour vérifier la commande du processus d'arrière-plan: les travaux:

$ Jobs -l

Pour vérifier la commande en cours d'exécution en arrière-plan:

$ fg

Pour tuer le processus actuel, utilisez son ID de travail avec la commande Kill. Pour vérifier l'identification des travaux, exécutez:

$ Jobs -l

Après avoir connu le processus d'identification des emplois en utilisant:

$ kill -9 [job-id]

Par exemple, pour tuer l'utilisation actuelle du processus de sommeil en cours d'exécution:

$ kill -9 6584

Pour confirmer si le processus est tué ou non, exécutez la commande Jobs:

$ Jobs -l

Nous pouvons voir que le processus de sommeil ne fonctionne plus en arrière-plan:

3: Utilisation de la commande nohup

La commande noHup est troisième sur notre liste de processus d'arrière-plan en cours d'exécution dans Linux. La commande signifie «non raccroche» et est utilisée pour empêcher le processus de résiliation jusqu'à la fin de la session terminale. Lorsqu'un processus est exécuté à l'aide de NoHup, il continue d'exécuter même si l'utilisateur se déconnecte et que la sortie du processus est redirigé vers un fichier nommé «Nohup.dehors".

La commande noHup pour ping google en continu en arrière-plan est et la sortie est redirigée vers un fichier texte Googleping.SMS:

$ nohup ping google.com> googleping.SMS &

Après avoir écrit cette commande, nous pouvons voir que le terminal est gratuit et un processus d'arrière-plan pour pinging en permanence Google fonctionne en arrière-plan.

Pour accéder au fichier journal, nous pouvons utiliser la commande suivante:

$ Cat Googleping.SMS

Le fichier journal est également accessible à l'aide de l'interface graphique à partir de l'écran d'accueil.

4: Utilisation de la commande Diet

La commande Diet supprime un processus de la coquille et l'exécute en arrière-plan. Lorsqu'un processus est renié, il n'est plus associé au terminal et continue de s'exécuter même après que l'utilisateur a enregistré ou clôturé le terminal.

Auparavant, nous avons utilisé la commande AMPERSAND «&» qui envoie le processus en arrière-plan après son exécution, mais à mesure que nous fermons le shell, le processus est terminé. Pour se débarrasser de cette commande de renie.

La commande Diet ne peut pas fonctionner de manière indépendante, mais un minimum d'un processus doit être exécuté en arrière-plan.

Exécutez la commande ci-dessous avec un & Ampersand Sign qui enverra votre commande à l'arrière-plan.

$ ping google.com> googleping.SMS &

Une fois le fichier créé, nous pouvons le répertorier à l'aide de la commande Jobs.

Maintenant, notre processus fonctionne en arrière-plan pour le détacher de l'utilisation du terminal:

$ Diet

Exécutez à nouveau la commande Jobs pour confirmer que le processus est détaché du terminal:

$ Jobs -l

Comme notre processus est en cours d'exécution, mais il n'est plus montré à l'intérieur du terminal:

Pour confirmer notre processus, nous pouvons utiliser la commande CAT pour accéder à ce fichier ping:

$ Cat Googleping.SMS

Nous avons réussi à détacher ce processus à partir du terminal, mais il fonctionne toujours en arrière-plan.

5: Utilisation de l'utilitaire TMUX

TMUX est une sorte d'utilité du multiplexeur terminal. En utilisant TMUX, nous pouvons créer plusieurs séances de terminal dans un seul shell. Il offre la possibilité d'exécuter des processus en arrière-plan.

Pour exécuter un processus d'arrière-plan dans TMUX, vous pouvez créer une nouvelle session, puis en détacher en utilisant la combinaison de clés Ctrl-B suivie de D.

Pour installer l'utilitaire TMUX sur Ubuntu et Linux Mint Use:

$ sudo apt install tmux

Pour installer sur Fedora Run:

$ sudo dnf installer tmux

Pour installer sur Arch Linux Run:

$ sudo pacman -s tmux

Exécutez maintenant la commande TMUX pour ouvrir un nouveau terminal:

$ tmux

Pour créer une nouvelle utilisation de session TMUX:

$ tmux new -s [session_id]

Pour répertorier toutes les sessions TMUX Utilisation:

$ tmux ls

Pour tuer une commande de session TMUX comme:

$ tmux kill-session -t [session_id]

Par exemple, tuer "0" Utilisation de la session TMUX:

$ tmux kill-session -t 0

Ici, nous avons répertorié la session active active en cours d'exécution et la tuer en utilisant la commande ci-dessus:

• • Se détacher de la session TMUX presse "Ctrl + B + D".
  • Pour obtenir une liste de toutes les commandes, appuyez sur «Ctrl + B+?".
  • Pour déplacer entre TMUX Windows, appuyez sur "Ctrl + B + O".

Pour diviser le terminal TMUX verticalement, appuyez sur «Ctrl + B» et taper %.

Pour revenir sur le terminal principal de tmux utiliser:

$ exit

Conclusion

Les applications d'arrière-plan en cours d'exécution dans Linux sont une fonctionnalité puissante qui permet aux utilisateurs de maintenir leurs tâches de longue date en cours d'exécution même après l'exécution du terminal ou la fermeture de la fenêtre. Habituellement un Ampersand & signe ou bg La commande est utilisée pour envoyer un processus en arrière-plan. Cependant, nous pouvons également utiliser nohup ou renier commande de détacher un processus du terminal. Enfin, nous pouvons utiliser le utilitaire TMUX Pour créer plusieurs terminaux et exécuter des processus d'arrière-plan sans perturber le terminal.