Opérations de processus Shell

$ dormir 100 &[1] 9298

Exemple : Afficher l'ID du processus

utiliser

 pidof

Vous pouvez afficher l'ID de processus du nom de programme spécifié :

 $ pidof sleep9298

Exemple : Afficher l'image mémoire d'un processus

 $ cat /proc/9298/maps08048000-0804b000 r-xp 00000000 08:01 977399 /bin/sleep0804b000-0804c000 rw -p 00003000 08:01 977399 /bin/sleep0804c000-0806d000 rw-p 0804c000 00:00 0 [tas]b7c8b000-b7cca000 r--p 00000000 08:01 443354...bfbd8000-bfbed000 rw-p bfbd8000 00:00 0 [pile]ffffe000-fffff000 r-xp 00000000 00:00 0 [vdso]

Une fois le programme exécuté, il est chargé en mémoire et devient un processus. Ce qui précède montre l'image mémoire (mémoire virtuelle) du processus, y compris les instructions du programme, les données et un certain espace de pile utilisé pour stocker les paramètres de ligne de commande du programme et les variables d'environnement. L'espace de tas utilisé pour l'application de mémoire dynamique a été alloué.

Pour plus de détails sur le processus d'exécution du programme sur la ligne de commande, veuillez vous référer à « Le moment de l'exécution du programme sous la ligne de commande Linux ».

En fait, il existe d'autres façons de créer un processus, c'est-à-dire de laisser le programme s'exécuter. Par exemple, grâce à certaines configurations, vous pouvez démarrer automatiquement le programme au démarrage du système (pour plus de détails, reportez-vous à .

 homme initialisant

), ou en configurant

 crond

(ou

 à

) pour lui permettre de démarrer le programme régulièrement. De plus, il existe une autre méthode, qui consiste à écrire un script Shell et à écrire le programme dans un fichier de script. Lorsque le fichier de script est exécuté, le programme dans le fichier sera exécuté et deviendra un processus. Les détails de ces méthodes ne seront pas introduits. Apprenons comment visualiser les propriétés du processus.

Une chose qui doit être ajoutée est : pour exécuter le programme sous la ligne de commande, vous pouvez passer

 ulimit

Les commandes intégrées sont utilisées pour définir les ressources qu'un processus peut utiliser, telles que le nombre maximum de descripteurs de fichiers qu'un processus peut ouvrir, l'espace maximum de la pile, l'espace mémoire virtuelle, etc. Pour une utilisation spécifique, voir

 helpulimit

.

Afficher les propriétés et l'état du processus

peut passer

 PS

Utilisez la commande pour afficher les attributs et l'état liés au processus. Ces informations incluent l'utilisateur auquel appartient le processus, le programme correspondant au processus et le.

 processeur

et l'utilisation de la mémoire et d'autres informations. La connaissance de la façon de les visualiser peut faciliter les analyses statistiques pertinentes et d'autres opérations.

Exemple : Afficher les attributs du processus via la commande ps

Affichez les propriétés de tous les processus actuels dans le système :

 $ps-ef

Afficher le processus correspondant au programme contenant un certain caractère dans la commande, processus

 IDENTIFIANT

est 1.

 ATS

pour? Indique qu'il n'est pas lié au terminal :

 $ ps -C init PID TTY TIME CMD 1 ?

Sélectionnez les processus démarrés par un utilisateur spécifique :

 $ ps -U faucon

Affiche le contenu spécifié selon le format spécifié. Ce qui suit affiche le nom de la commande et

 processeur

Taux d'utilisation :

 $ps -e -o %C %c

Imprimer

 processeur

Top 4 des programmes les plus utilisés :

 $ ps -e -o %C %c | trier -u -k1 -r | head -5 7.5 firefox-bin 1.1 Xorg 0.8 scim-panel-gtk 0.2 scim-bridge

Obtenez les cinq processus utilisant la plus grande mémoire virtuelle :

 $ ps -e -o %z %c | trier -n -k1 -r | head -5349588 firefox-bin 96612 xfce4-terminal 88840 xfdesktop 76332 gedit 58920 scim-panel-gtk

Exemple : Afficher l'affinité du processus via pstree

Il existe une relation de « parenté » entre tous les processus du système, qui peut être

 pstree

Découvrez cette relation :

 $pstree

L'arborescence des appels des processus système sera imprimée ci-dessus et vous pourrez clairement voir la relation d'appel entre tous les processus actifs dans le système actuel.

Exemple : utilisez top pour afficher dynamiquement les informations sur le processus

 $ en haut

La plus grande caractéristique de cette commande est qu'elle peut afficher dynamiquement les informations sur le processus. Bien entendu, elle fournit également d'autres paramètres, tels que.

 -S

Vous pouvez le trier et l'afficher en fonction du temps d'exécution cumulé, ou vous pouvez utiliser

 -u

Afficher les processus démarrés par un utilisateur spécifié, etc.

Remplir:

 haut

La commande prend en charge l'interactivité, par exemple elle prend en charge

 toi

La commande affiche tous les processus de l'utilisateur et prend en charge le passage

 k

Commande pour tuer un processus si vous l'utilisez ;

 -n 1

option pour activer le mode de traitement par lots, l'utilisation spécifique est :

 $ haut -n 1 -b

Exemple : S'assurer qu'une seule copie d'un programme spécifique est en cours d'exécution

Discutons d'un problème intéressant : comment exécuter un seul programme en même temps.

Cela signifie que pendant qu'un programme est en cours d'exécution, il ne peut pas être redémarré. Alors que faire ?

Si le même programme est copié en plusieurs copies et porte des noms de fichiers différents et est placé à des emplacements différents, ce sera pire, considérons donc le cas le plus simple, c'est-à-dire que ce programme est unique sur l'ensemble du système et que le nom est également unique. . Dans ce cas, quelles sont les manières de répondre aux questions ci-dessus ?

Le mécanisme général est le suivant : vérifier au début du programme s'il a été exécuté. S'il est exécuté, arrêter, sinon continuer l'exécution du code suivant.

Les stratégies sont diverses. Puisque l'hypothèse précédente garantissait l'unicité du nom et du code du fichier programme, donc à travers

 PS

La commande recherche les noms de programme correspondant à tous les processus en cours et les compare un à un avec son propre nom de programme. S'il existe déjà, cela signifie qu'il a déjà été exécuté.

 ps -e -o %c | tr -d | grep -q ^init$ #Vérifiez si le programme actuel est exécuté [ $? -eq 0 ] && exit #Si c'est le cas, alors exit, $? a été exécuté avec succès

Chaque fois qu'il s'exécute, vérifiez d'abord s'il existe un processus qui s'enregistre à l'emplacement spécifié.

 IDENTIFIANT

fichier, s'il n'existe pas, continuez l'exécution, s'il existe, affichez le processus

 IDENTIFIANT

Est-il en cours d'exécution ? Si c'est le cas, quittez, sinon réécrivez le nouveau processus dans le fichier.

 IDENTIFIANT

, et continuez.

 pidfile=/tmp/$0.pidif [ -f $pidfile ]; alors OLDPID=$(cat $pidfile) ps -e -o %p | grep -q ^$OLDPID$ [ $ -eq 0 ] && exitfiecho $$ > $pidfile#... Corps de code# Définit l'action du signal 0. Lorsque le programme se termine, le signal est déclenché pour supprimer le fichier temporaire trap rm $pidfile 0

N'hésitez pas à utiliser vous-même davantage de stratégies de mise en œuvre !

Ajuster la priorité du processus

En plus de garantir que chaque processus peut être exécuté sans problème, afin de permettre à certaines tâches d'être accomplies en premier, le système utilisera certaines méthodes de planification lors de la planification des processus, telles que l'algorithme de planification commun de rotation des tranches de temps en fonction de la priorité. Dans ce cas, vous pouvez passer

 renice

Ajustez la priorité d'un programme en cours d'exécution, par exemple : `

Exemple : Obtenir la priorité du processus

 $ ps -e -o %p %c %n | grep xfs 5089 xfs 0

Exemple : Ajuster la priorité d'un processus

 $ renice 1 -p 5089renice : 5089 : setpriority : Opération non autorisée$ sudo renice 1 -p 5089 #Des autorisations sont requises [sudo] mot de passe pour falcon:5089 : ancienne priorité 0, nouvelle priorité 1$ ps -e -o %p % c %n | grep xfs #Regardez à nouveau, la priorité a été ajustée 5089 xfs 1

processus final

Puisque vous pouvez exécuter un programme et créer un processus via la ligne de commande, il existe également un moyen d'y mettre fin. peut passer

 tuer

La commande envoie un signal au processus démarré par l'utilisateur pour terminer le processus. Bien entendu, c'est "universel".

 racine

presque

 tuer

Tous les processus (sauf

 initialisation

dehors). Par exemple,

Exemple : Terminer le processus

 $ dormir 50 & #Démarrer un processus [1] 11347$ tuer 11347

 tuer

La commande enverra un signal de fin par défaut (

 SIGTERM

) au programme et laissez le programme se terminer, mais

 tuer

D'autres signaux peuvent également être envoyés et ceux-ci peuvent être définis via

 signal homme 7

Vous pouvez également le consulter via

 tuer -l

Énumérez-le.

 $ man 7 signal$ kill -l 1) SIGHUP 2) SIGINT 3) SIGQUIT 4) SIGILL 5) SIGTRAP 6) SIGABRT 7) SIGBUS 8) SIGFPE 9) SIGKILL 10) SIGUSR1 11) SIGSEGV 12) SIGUSR213) SIGPIPE 14) SIGALRM 15 ) SIGTERME 16) SIGSTKFLT17) SIGCHLD 18) SIGCONT 19) SIGSTOP 20) SIGTSTP21) SIGTTIN 22) SIGTTOU 23) SIGURG 24) SIGXCPU25) SIGXFSZ 26) SIGVTALRM 27) SIGPROF 28) SIGWINCH29) SIGIO 30) SIGPWR 31) SIGSYS 34) SIGRTMIN35) SIGRTMIN+1 36) SIGRTMIN+2 37) SIGRTMIN+3 38) SIGRTMIN+439) SIGRTMIN+5 40) SIGRTMIN+6 41) SIGRTMIN+7 42) SIGRTMIN+843) SIGRTMIN+9 44) SIGRTMIN+10 45) SIGRTMIN+11 46) SIGRTMIN+1247) SIGRTMIN+13 48) SIGRTMIN+14 49) SIGRTMIN+15 50) SIGRTMAX-1451) SIGRTMAX-13 52) SIGRTMAX-12 53) SIGRTMAX-11 54) SIGRTMAX-1055) SIGRTMAX-9 56) SIGRTMAX-8 57) SIGRTMAX-7 58) SIGRTMAX-659) SIGRTMAX-5 60) SIGRTMAX-4 61) SIGRTMAX-3 62) SIGRTMAX-263) SIGRTMAX-1 64) SIGRTMAX

Exemple : suspendre un processus

Par exemple, utilisez

 tuer

commande à envoyer

 ARRÊT DE SIGNALISATION

Signaler à un programme de mettre en pause puis de l'envoyer

 SIGCONT

Le signal le fait fonctionner.

 $ sleep 50 &[1] 11441$ jobs[1]+ Exécution de sleep 50 &$ kill -s SIGSTOP 11441 #Cela équivaut à effectuer l'opération CTRL+Z sur un processus de premier plan $ jobs[1]+ Arrêt du sommeil 50$ kill - s SIGCONT 11441 #Ceci est équivalent à l'opération bg %1 précédente que nous avons utilisée pour exécuter un processus en arrière-plan $ jobs[1]+ Exécution de sleep 50 &$ kill %1 #Sous la session en cours, vous pouvez également contrôler le processus via le numéro de travail $ jobs[1]+ Sommeil terminé 50

visible

 tuer

La commande fournit de très bonnes fonctions, mais elle ne peut se baser que sur le processus

 IDENTIFIANT

ou un travail pour contrôler le processus, tandis que

 tuer

et

 tuer tout

D'autres options sont fournies pour étendre les moyens de contrôler un processus par son nom de programme ou même son nom d'utilisateur. Veuillez vous référer à leurs manuels pour plus d'utilisation.

Exemple : Afficher l'état de sortie du processus

Lorsque le programme se termine, comment déterminer si le programme s'est terminé normalement ou anormalement ? Vous vous souvenez encore de ce classique sous Linux ?

 Bonjour le monde

Programme? A la fin du code il y a toujours une ligne

 retourner 0

déclaration. ce

 retourner 0

Cela permet en fait au programmeur de vérifier si le processus se termine normalement. Si le processus renvoie une valeur différente, on peut alors affirmer en toute sécurité que le processus s'est terminé anormalement car il n'a pas encore été exécuté.

 retourner 0

Cette déclaration existe.

Alors comment vérifier l’état de sortie du processus, c’est-à-dire la valeur renvoyée ?

exister

 Coquille

, vous pouvez vérifier cette variable spéciale

 $?

, qui stocke l'état de sortie après l'exécution de la commande précédente.

 $ test1bash : test1 : commande introuvable$ echo $?127$ cat ./test.c | grep bonjour$ echo $?1$ cat ./test.c | $?0

Il semble que renvoyer 0 soit devenu une règle tacite. Bien qu'il n'existe aucune norme qui le stipule clairement, lorsque le programme revient normalement, il peut toujours être renvoyé.

 $?

0 est détecté dans , mais en cas d'anomalie, une valeur non 0 est toujours détectée. Cela nous indique qu'à la fin du programme, il est préférable de suivre les

 sortie 0

pour que tout le monde puisse réussir le test

 $?

Déterminez si le programme se termine normalement. Si un jour, quelqu'un utilise occasionnellement votre programme et essaie de vérifier son état de sortie, mais que vous renvoyez inexplicablement un

 -1

Ou 1, alors il sera très angoissé et se demandera où est le problème dans le programme qu'il a écrit lui-même. Il le vérifiera pendant longtemps mais sera perdu car il vous fait tellement confiance qu'il ne doute jamais de vos habitudes de programmation. du début à la fin. Ce sera différent !

communication de processus

Pour faciliter la conception et la mise en œuvre, une tâche importante est généralement divisée en modules plus petits. Les différents modules deviennent des processus une fois démarrés. Comment communiquent-ils entre eux pour échanger des données et travailler ensemble ? De nombreuses méthodes sont mentionnées dans le livre "Advanced Programming in UNIX Environment", telles que les tubes (tubes sans nom et tubes nommés), les signaux (

 signal

), message (

 Message

) file d'attente (file d'attente des messages), mémoire partagée (

 mmap/munmap

), sémaphore (

 sémaphore

, principalement utilisé pour la synchronisation, entre processus, entre différents threads d'un processus), les sockets (

 Douille

, prend en charge la communication des processus entre différentes machines), etc., et dans Shell, les tuyaux et les signaux sont généralement utilisés directement. Ce qui suit présente principalement certaines utilisations des canaux et des mécanismes de signal dans la programmation Shell.

Exemple : canal sans nom (canal)

Sous Linux, vous pouvez passer

 |

Connectez deux programmes afin de pouvoir l'utiliser pour connecter l'entrée de ce dernier programme à la sortie du programme précédent, c'est pourquoi on l'appelle clairement un tube. En langage C, il est très simple et pratique de créer un tube sans nom.

 tuyau

fonction, en passant un élément à deux éléments

 int

Un tableau de types fera l'affaire. Ce tableau stocke en fait deux descripteurs de fichiers. Une fois que le processus parent a écrit quelque chose dans le premier descripteur de fichier, le processus enfant peut le lire à partir du premier descripteur de fichier.

Si vous utilisez trop de lignes de commande, ce tube

 |

Il doit être utilisé fréquemment. Par exemple, il y a une démonstration ci-dessus

 PS

Le résultat de la commande est le suivant

 grep

Entrée de commande :

 $ps-ef |

Vous pensez peut-être que ce « tuyau » est si magique qu'il peut réellement relier l'entrée et la sortie de deux programmes. Comment sont-ils implémentés ? En fait, lorsqu'un tel ensemble de commandes est entré, le shell actuel effectuera une analyse appropriée, associera la sortie du processus précédent au descripteur de fichier de sortie du tube et associera l'entrée du processus suivant au descripteur de fichier d'entrée de le tuyau. Ce processus d’association Redirect fonctionne via l’entrée et la sortie.

 dup

(ou

 fcntl

) à réaliser.

Exemple : canal nommé

Un tube nommé est en fait un fichier (un tube sans nom est aussi comme un fichier. Bien qu'il soit lié à deux descripteurs de fichier, il ne peut être lu que d'un côté et écrit de l'autre. Cependant, ce fichier est assez spécial. doit satisfaire au principe du premier entré, premier sorti pendant le fonctionnement, et si vous essayez de lire à partir d'un canal nommé qui n'a pas de contenu, vous serez bloqué de même, si vous essayez d'écrire dans un canal nommé et qu'aucun programme n'essaye actuellement. pour le lire, vous serez bloqué. Voir l'effet ci-dessous.

 $ mkfifo fifo_test #Créez un célèbre tube via la commande mkfifo $ echo somefefe > fifo_test #Essayez d'écrire du contenu dans le fichier fifo_test, mais il est bloqué. Vous devez ouvrir un autre terminal pour continuer les opérations suivantes $ cat fifo_test #Ouvrir un autre terminal. , rappelez-vous, ouvrez-en un autre. Essayer de lire le contenu de fifo_test fivefefe

Voici

 écho

et

 chat

sont deux programmes différents, dans ce cas, par

 écho

et

 chat

Il n'y a aucune relation parent-enfant entre les deux processus démarrés. Cependant, ils peuvent toujours communiquer via des canaux nommés.

Un tel procédé de communication est très adapté à certaines situations : par exemple, il existe une telle architecture. Cette architecture est constituée de deux applications dont l'une lit en boucle en continu.

 fifo_test

contenu afin de déterminer ce qu’il doit faire ensuite. Si ce canal n'a pas de contenu, alors il y sera bloqué sans consommer de ressources en raison d'une boucle infinie. L'autre continuera à circuler comme programme de contrôle.

 fifo_test

Écrivez-y des informations de contrôle pour indiquer au programme précédent quoi faire. Écrivez un exemple très simple ci-dessous. Vous pouvez concevoir certains codes de contrôle, puis le programme de contrôle continue à

 fifo_test

Écrivez-y, puis l'application effectue différentes actions en fonction de ces codes de contrôle. Bien entendu, vous pouvez également vous rendre sur

 fifo_test

Transmettez d’autres données à l’exception du code de contrôle.

code d'application

 $ cat app.sh #!/bin/bash FIFO=fifo_test while :; do CI=`cat $FIFO` #CI --> Control Info case $CI in 0) echo Le numéro de CONTRÔLE est ZÉRO, faites quelque chose... ;; 1) echo Le numéro de CONTROL est UN, faites quelque chose... ;; *) echo Le numéro de CONTROL n'est pas reconnu, faites autre chose... ;;

Code du programme de contrôle

 $ cat control.sh #!/bin/bash FIFO=fifo_test CI=$1 [ -z $CI ] && echo les informations de contrôle ne doivent pas être vides && exit echo $CI > $FIFO

Un programme contrôle le travail d'un autre programme via des tuyaux

 $ chmod +x app.sh control.sh #Modifier les autorisations exécutables de ces deux programmes afin que les utilisateurs puissent les exécuter $ ./app.sh #Démarrez cette application dans un terminal et envoyez le contrôle via ./control.sh Vérifiez la sortie après le code. Le numéro de CONTRÔLE est UN, faites autre chose... #Après l'envoi de 1, Le numéro de CONTRÔLE est ZÉRO, faites quelque chose... #Après l'envoi de 0, Le numéro de CONTRÔLE n'est pas reconnu, faites autre chose... #Envoyer un inconnu Après le code de contrôle $ ./control.sh 1 #Dans un autre terminal, envoyez des informations de contrôle pour contrôler le travail de l'application $ ./control.sh 0 $ ./control.sh 4343

Une telle architecture d'application est très adaptée à la conception de tâches multi-programmes locales si elle est combinée avec.

 webcgi

, alors il répondra également aux exigences de la télécommande. introduire

 webcgi

Le seul changement est que le programme de contrôle

 ./control.sh

mettre dedans

 la toile

de

 cgi

répertoire et apportez-y quelques modifications pour qu'il soit conforme à

 Image de synthèse

spécifications, qui incluent une représentation du format de sortie du document (nécessité de sortir au début du fichier

 type de contenu : texte/html

et une ligne vierge) et l'acquisition des paramètres d'entrée

 (Internet

Les paramètres d'entrée sont stockés dans

 QUERY_STRING

variables d'environnement). Donc très simple

 Image de synthèse

Le programme de contrôle peut être écrit comme ceci :

 #!/bin/bashFIFO=./fifo_testCI=$QUERY_STRING[ -z $CI ] && echo les informations de contrôle ne doivent pas être vides && exitecho -e content-type: text/htmlnnecho $CI > $FIFO

En utilisation réelle, veuillez vous assurer

 contrôle.sh

capable d'accéder

 fifo_test

pipe, et dispose d'autorisations d'écriture pour le contrôle via le navigateur

 app.sh

:

 http://adresseip_or_dns/cgi-bin/control.sh?0

point d'interrogation

 ?

Le contenu suivant est

 QUERY_STRING

, semblable au précédent

 1 $

.

Une telle application revêt une grande importance pratique pour le contrôle à distance, en particulier pour le contrôle à distance des systèmes embarqués. Lors du cours d'été de l'année dernière, nous avons ainsi mis en œuvre le contrôle à distance des moteurs. Tout d'abord, une application simple est implémentée pour contrôler la rotation du moteur, y compris le contrôle de la vitesse, de la direction, etc. Afin de réaliser le contrôle à distance, nous avons conçu des codes de contrôle pour contrôler différentes propriétés liées à la rotation du moteur.

En langage C, si vous souhaitez utiliser un tube nommé, c'est similaire à Shell, sauf que lors de la lecture et de l'écriture de données, utilisez

 lire

,

 écrire

Appeler, créer

 fifo

Utilisé quand

 mkfifo

appel de fonction.

Exemple : signal

Les signaux sont des interruptions logicielles auxquelles les utilisateurs Linux peuvent accéder via

 tuer

La commande envoie un signal spécifique à un processus, ou certains signaux peuvent être envoyés via le clavier, comme

 CTRL+C

peut déclencher

 SGIINT

signal, tandis que

 CTRL+

peut déclencher

 SGIQUIT

Signaux, etc. De plus, le noyau enverra également des signaux au processus dans certaines circonstances, par exemple lors d'un accès à la mémoire hors des limites.

 SGISEGV

Les signaux, bien sûr, et le processus lui-même peuvent également passer

 tuer

,

 augmenter

Attendez que la fonction s'envoie un signal. Pour les types de signaux supportés sous Linux, vous pouvez passer

 signal homme 7

ou

 tuer -l

Voir les listes et instructions associées.

Pour certains signaux, le processus aura des actions de réponse par défaut, tandis que pour certains signaux, le processus pourra simplement les ignorer. Bien entendu, les utilisateurs peuvent également définir des fonctions de traitement spéciales pour certains signaux. Dans le shell, vous pouvez passer

 piège

commande (commande intégrée au Shell) pour définir une action en réponse à un signal (une commande ou une fonction définie), et en langage C vous pouvez utiliser

 signal

Appelez la fonction de gestionnaire enregistrée pour un signal. Ceci est juste une démonstration

 piège

Utilisation de la commande.

 $ function signal_handler { echo hello, world.; } #Définissez la fonction signal_handler $ trap signal_handler SIGINT #Exécutez ce paramètre de commande : print hello, world lors de la réception du signal SIGINT $ hello, world #Appuyez sur CTRL+C pour voir l'écran Le bonjour et les chaînes du monde sont sorties

De même, si vous définissez l'action de réponse du signal 0, vous pouvez utiliser

 piège

Pour simuler le programme en langage C

 une sortie

Enregistrement de la fonction de terminaison du programme, c'est-à-dire via

 piège signal_handler SIGQUIT

ensemble

 gestionnaire_signal

La fonction sera exécutée à la fin du programme. Le signal 0 est un signal spécial dans

 POSIX.1

Le signal numéro 0 est défini comme un signal nul, qui est souvent utilisé pour déterminer si un processus spécifique existe toujours. Ce signal est déclenché lorsqu'un programme se termine.

 $ cat sigexit.sh#!/bin/bashfunction signal_handler { echo hello, world}trap signal_handler 0$ chmod +x sigexit.sh$ ./sigexit.sh #La programmation actuelle du Shell utilisera cette méthode pour effectuer un nettoyage à la fin du programme Fin du travail sur les fichiers temporaires bonjour tout le monde

Emplois et contrôle des emplois

Lorsque nous passons plusieurs commandes

 |,>,<, ;, (,)

Lorsqu'elles sont combinées, cette séquence de commandes démarre généralement plusieurs processus qui communiquent via des tuyaux, etc. Parfois, lors de l'exécution d'une tâche, d'autres tâches doivent être traitées. Vous ajoutez donc souvent un & à la fin de la séquence de commandes, ou après avoir exécuté la commande, appuyez sur

 CTRL+Z

Met la commande précédente en pause. afin d'accomplir d'autres tâches. Après avoir terminé quelques autres tâches, passez

 fg

La commande fait passer la tâche en arrière-plan au premier plan. Un tel processus de contrôle est généralement appelé contrôle de travail, et ces séquences de commandes sont appelées travaux. Ce travail peut impliquer un ou plusieurs programmes, un ou plusieurs processus. Ce qui suit présente plusieurs opérations de contrôle des tâches couramment utilisées.

Exemple : créer un processus en arrière-plan et obtenir le numéro de tâche et le numéro de processus du processus

 $ dormir 50 &[1] 11137

Exemple : amener la tâche au premier plan et la mettre en pause

Utiliser les commandes intégrées de Shell

 fg

Amenez le travail 1 au premier plan et appuyez sur

 CTRL+Z

Suspendre le processus

 $ fg %1sommeil 50^Z[1]+ Sommeil arrêté 50

Exemple : Afficher l'état actuel du travail

 $ jobs # Vérifiez l'état actuel du travail, un travail est arrêté [1] + Arrêté de veille 50$ sleep 100 & # Laisser un autre travail s'exécuter en arrière-plan [2] 11138$ jobs # Vérifiez l'état actuel du travail, un est en cours d'exécution et un est arrêté [ 1]+ Arrêt du sommeil 50[2]- Exécution du sommeil 100 &

Exemple : démarrer un processus arrêté et l'exécuter en arrière-plan

 $ bg %1[2]+ sommeil 50 &

Cependant, pour utiliser le contrôle des tâches sous la ligne de commande, le shell actuel, le pilote du terminal du noyau, etc. doivent prendre en charge le contrôle des tâches.

Références

"Programmation avancée dans un environnement UNIX"