En föräldraprocess är, inom datavetenskap , en process som har skapat ("uppstått") en eller flera underordnade processer ("barnprocesser"). På grund av vilket kan processen bli ett barn eller förälder och vice versa. Med hjälp av länkmekanismer i operativsystem kan alltså hela hierarkier av relaterade processer bildas [1] [2] [3] .
Dessutom, från funktionerna för att skapa sådana hierarkier, kan det noteras att när man skapar underordnade processer kan vissa av egenskaperna hos föräldraprocessen överföras, och när styrsignaler skickas till förälderprocessen kan signaler överföras från "föräldern" ” till ”barnen”. Ett exempel skulle vara vilken modern webbläsare som helst , där varje enskild flik skapas i en separat underordnad webbläsarprocess, och om du skickar en avslutningssignal till webbläsaren, slutar också alla dess flikar att fungera.
På Unix-liknande operativsystem skapas varje process utom process 0 (swapper) när en annan process utfärdar gaffelsystemanropet . Processen som kallade gaffel är den överordnade processen, och den nyskapade processen är den underordnade processen. Varje process (förutom process 0) har en överordnad process, men kan ha många underordnade processer.
Operativsystemets kärna identifierar varje process med dess process - ID . Process 0 är en speciell process som skapas när systemet startar, efter att ha splittrat en underordnad process (process 1) blir process 0 en "swapper process " (även känd som "swapper process" och " idle task "). Process 1, känd som init , är huvudfadern till alla andra processer i systemet.
I Linux-kärnan , där det finns en mycket subtil skillnad mellan POSIX- processer och trådar , finns det två typer av överordnade processer, nämligen "riktiga förälder" och "förälder". Föräldern är den process som tar emot SIGCHLD- signalen när barnet avslutas, medan den riktiga föräldern är tråden som faktiskt skapade den underordnade processen i en flertrådsmiljö . För en normal process är dessa två värden desamma, men för en POSIX-tråd som fungerar som en process kan dessa två värden vara olika.
Operativsystemet upprätthåller en tabell som associerar varje process, genom dess process-ID (vanligen kallad "PID" - "Process Identifier") med de data som är nödvändiga för dess funktion. Under en processs livslängd kan sådan data inkludera minnessegmenten som tilldelats processen, argumenten med vilka den anropades, miljövariabler , resursanvändningsräknare, användar -ID , grupp-ID, och möjligen andra typer av information.
När en process avslutar sin exekvering, antingen genom att anropa exit- funktionen (även om det är implicit, genom att köra ett returkommando från huvudfunktionen) eller genom att ta emot en signal som får den att avslutas abrupt, släpper operativsystemet de flesta resurser och information associerad med den processen. , men behåller fortfarande resursanvändningen och utgångsstatuskoden eftersom den överordnade processen kan vara intresserad av att veta om den underordnade processen lyckades (med standardfunktionerna för att avkoda utgångsstatuskoden) och mängden systemresurser, vilket den förbrukades under dess utförande.
Som standard antar systemet att föräldraprocessen faktiskt är intresserad av sådan information vid den tidpunkt då barnet avslutar, och skickar därför en SIGCHLD- signal till föräldraprocessen för att varna att det finns en del data om barnet som behöver samlas in. Den här insamlingen görs genom att anropa en funktion i wait-familjen (antingen wait sig själv eller till exempel waitpid , waitid eller wait4 ). När denna insamling är klar släpper systemet dessa sista informationsbitar om den underordnade processen och tar bort dess PID från processtabellen. Men om den överordnade processen försenar (eller misslyckas med att göra det alls) med att samla in barnets data, har systemet inget annat val än att lagra barnets PID och avslutningsdata i processtabellen på obestämd tid.
En sådan avslutad process, vars data inte har samlats in, kallas en zombieprocess, eller helt enkelt en zombie på UNIX -språk . Namnet är en lekfull analogi på grund av övervägandet av en avslutad process som "inte längre levande" eller "död" eftersom den verkligen har upphört att fungera och inte kan "dö".
Zombieprocesser kan skapa problem på system med begränsade resurser eller processtabeller av begränsad storlek, eftersom skapandet av nya aktiva processer kan förhindras av brist på resurser som fortfarande är reserverade av zombieprocesser.
En föräldralös process är motsatsen till en zombieprocess, och hänvisar till fallet där en föräldraprocess avslutas innan dess underordnade processer sägs vara "föräldralösa". Till skillnad från den asynkrona aviseringen från barn till förälder som inträffar när den underordnade processen avslutas (via SIGCHLD-signalen), aviseras inte underordnade processer i tid när deras överordnade process har avslutats. Istället omdefinierar systemet helt enkelt "förälder-PID"-fältet i underordnad processdata till en process som är "förfader" till alla andra processer i systemet, vars PID vanligtvis är "1" och vars namn traditionellt är "init" ( med undantag för Linux-kärnan) version 3.4 och senare). Detta innebär att init "adopterar" varje föräldralös process i systemet om det förlorar sin förälder.
Efter Linux 3.4-kärnan är detta inte längre fallet, i själva verket kan processer utfärda prctl -systemanropet med alternativet PR_SET_CHILD_SUBREAPER, och som ett resultat kommer de, och inte process nummer 1, att bli förälder till något av deras föräldralösa barn processer. Det här är hur moderna tjänstehanterare och demonkontrollverktyg fungerar , inklusive systemd , upstart och nosh service manager.
Barnprocess