Operativsystem använder olika strategier för att förhindra svält i resursallokeringsprocesser. Svält inträffar när en process upprepade gånger nekas tillgång till en resurs, även om den kan utföra sitt arbete. Här är en uppdelning av vanliga tekniker:
1. Prioritetsbaserad schemaläggning med åldrande:
* Problemet: Processer med hög prioritering kan kontinuerligt monopolisera resurser, vilket förhindrar lägre prioriteringsprocesser från att någonsin få en chans att köra och potentiellt orsaka svält.
* Lösningen - åldrande:
* koncept: Öka med tiden öka prioriteringen av processer som har väntat länge för att skaffa en resurs.
* Implementering: OS ökar regelbundet prioriteringen av väntningsprocesser. Detta säkerställer att till och med lågprioriterade processer så småningom kommer att bli berättigade att köra.
* Exempel: En process som väntar på CPU -tid kan ha sin prioritering som stötte på några få klockfästingar. Så småningom kommer det att bli den högsta prioritetsprocessen och planeras.
2. Rättvis kö och viktad rättvis kö:
* Problemet: Processer som begär samma resurs kan få oförutsägbara tilldelningar, vilket potentiellt gynnar vissa framför andra upprepade gånger.
* Lösningen - rättvis kö:
* koncept: Garantera varje process en rättvis andel av en resurs över tid.
* Implementering:
* Processer som väntar på en resurs placeras i en kö.
* Resursen tilldelas processer på ett rättvist sätt, ofta med rund-robin eller liknande schemaläggningsalgoritmer.
* Varje process ges en tidsskiva (eller annan resurskvot) innan en annan process får en tur.
* Weighted Fair Queuing (WFQ):
* koncept: En variation av rättvis kö där varje process tilldelas en vikt som bestämmer dess relativa andel av resursen.
* Implementering:
* Processer med högre vikter får proportionellt större skivor av resursen.
* Detta möjliggör prioritering av viktiga processer samtidigt som man fortfarande säkerställer att andra processer får viss åtkomst.
3. Resursallokering med förebyggande/undvikande av dödslås:
* Problemet: Deadlock kan leda till svält. Om processer sitter fast och väntar på varandras resurser, kan vissa vara på obestämd tid blockerade. Även om dödläget är trasigt kan samma processer upprepade gånger väljas som offer, vilket leder till svält.
* Lösningen:
* Deadlock Prevention: Strukturellt utformar resursallokeringssystemet för att eliminera de villkor som orsakar dödläge. Detta kan innebära:
* Mutual uteslutande eliminering (vanligtvis inte genomförbar): Gör det möjligt för resurser att användas av flera processer samtidigt.
* Håll och vänta förebyggande: Kräva en process för att begära alla sina resurser på en gång, eller släppa alla hållna resurser innan du begär mer.
* Ingen förhandsavdelning: Låt operativsystemet tvinga bort resurser från en process (om processen håller en resurs som en annan process behöver och väntar på en annan resurs).
* Circular Wait Prevention: Inför en total beställning av resurstyper och kräver processer för att begära resurser i stigande ordning.
* Dödlåsets undvikande: Övervaka dynamiskt övervaka resursallokeringstillståndet och undvika tilldelning av resurser om det kan leda till ett dödläge. Bankers algoritm är ett vanligt exempel.
* Varför detta hjälper svält: Genom att undvika deadlocks säkerställer operativsystemet att resurser så småningom frigörs och görs tillgängliga för att vänta processer, vilket minskar sannolikheten för obestämd blockering.
4. Bokningsbaserade system:
* Problemet: Processer kan kontinuerligt överträffa av andra för resursåtkomst.
* Lösningen:
* koncept: Låt processer reservera resurser i förväg.
* Implementering:
* En process kan begära en garanterad fördelning av en resurs för en viss period.
* OS säkerställer att resursen är tillgänglig när processen behöver den.
* Varför detta hjälper svält: Reservation förhindrar att en process upprepade gånger nekas åtkomst eftersom den inte kan konkurrera med de omedelbara kraven från andra processer. Det säkerställer en viss minsta servicenivå.
5. Lotteriplanering:
* Problemet: Processer kan vara konsekvent olyckliga i slumpmässiga tilldelningar.
* Lösningen:
* koncept: Ge processer "lotteri för en resurs. OS väljer slumpmässigt en biljett, och processen håller den biljetten får resursen.
* Implementering:
* Varje process tilldelas ett antal biljetter proportionella mot dess betydelse eller behov.
* OS har ett lotteri för att avgöra vilken process som får resursen.
* Varför detta hjälper svält: Även om det fortfarande är möjligt för en process att bli otur i ett enda lotteri, med tiden, kommer processer med fler biljetter statistiskt att få en större andel av resursen, vilket förhindrar permanent förnekande av service. Ju fler biljetter en process har, desto högre är chansen att vinna. Även processer med få biljetter har en icke-noll chans att vinna, vilket förhindrar fullständig svält.
6. Feedbackmekanismer:
* Problemet: Statiska schemaläggningsalgoritmer får inte anpassa sig bra till förändrade systemförhållanden.
* Lösningen:
* koncept: Övervaka processernas prestanda och justera resursallokering därefter.
* Implementering:
* OS spårar hur länge processer som har väntat på resurser.
* Om en process har väntat på överdriven tid kan operativsystemet öka sin prioritering, fördela mer resurser eller byta till en annan schemaläggningsalgoritm.
* Varför detta hjälper svält: Feedbackmekanismer gör det möjligt för operativsystemet att dynamiskt svara på svältsituationer och vidta korrigerande åtgärder.
Nyckelöverväganden:
* overhead: Alla dessa lösningar har en viss omkostnad. Algoritmens komplexitet påverkar CPU -användning och spårning av väntetider kräver minne.
* Rättvisa kontra effektivitet: Ofta finns det en avvägning mellan rättvisa (förhindrar svält) och övergripande systemeffektivitet. Ett helt rättvist system kanske inte är det mest effektiva när det gäller genomströmning.
* Kontextspecifikt: Det bästa tillvägagångssättet för att förhindra svält beror på att den specifika resursen tilldelas, processernas natur och de övergripande systemmålen. Ett realtidsoperativsystem (RTO) har strängare krav än ett allmänt operativsystem.
Sammanfattningsvis använder operativsystem en mängd olika tekniker, ofta i kombination, för att förhindra svält och se till att alla processer så småningom får de resurser de behöver för att slutföra sina uppgifter. Nyckeln är att balansera rättvisa, effektivitet och systemets specifika krav.
