Slaap()-functie in C-taal

Als we bijvoorbeeld een consoleapplicatie ontwikkelen waarin we de gebruiker moeten informeren over de taken die achtereenvolgens zullen worden uitgevoerd, moeten de informatieberichten gedurende een redelijke tijd blijven bestaan, zodat de gebruiker de tijd heeft om ze te lezen voordat ze worden gewist en het programma gaat door naar het volgende commando.

In dit Linuxhint-artikel leer je hoe je de functie sleep() gebruikt om in realtime vertragingen te creëren. We laten u de syntaxis en beschrijving van deze functie zien, evenals de opties die POSIX biedt om vertragingen te creëren met fracties van minder dan een seconde. Vervolgens laten we u aan de hand van praktische voorbeelden, codes en afbeeldingen zien hoe u de uitvoering van een programma kunt vertragen en welke effecten signalen op deze functie hebben.

Syntaxis van de functie Sleep() in C-taal

Beschrijving van de functie Sleep() in C-taal

De functie sleep() zet het proces of de thread in de slaapstand gedurende de tijd in seconden die is opgegeven in het invoerargument 'sec', dat een geheel getal zonder teken is. Zodra de functie sleep() is aangeroepen, slaapt het aanroepproces totdat er een time-out optreedt of een signaal wordt ontvangen.

Deze functie wordt vaak gebruikt om lange vertragingen van meer dan 1 seconde af te dwingen bij de uitvoering van realtime processen. Voor vertragingen van minder dan 1 seconde biedt POSIX de microseconde-resolutiefunctie usleep(), die dezelfde methodeaanroep gebruikt als sleep(). Voor de vertragingen van minder dan 1 microseconde is er ook de functie nanosleep() met een resolutie van 1 nanoseconde, maar met een andere aanroepmethode waarbij deze de “timespec”-structuren gebruikt als invoerargumenten om de vertragingstijd in te stellen.

Als de functie sleep() alle opgegeven tijd heeft verbruikt, retourneert deze 0 als resultaat. Als de uitvoering wordt onderbroken door de aankomst van een signaal voordat de opgegeven tijd is verstreken, retourneert het het resterende aantal seconden tot dat tijdstip.

De functie sleep() wordt gedefinieerd in de header “unistd.h”. Om het te gebruiken, moeten we dit bestand als volgt in de code opnemen:

Hoe u vertragingen in een proces kunt introduceren met de functie Sleep().

In dit voorbeeld maken we een timer die bestaat uit een oneindige lus waarin we het bericht ‘Verstreken tijd’ afdrukken in de opdrachtconsole, gevolgd door de verstreken seconden van het proces. Elk van deze lussen wordt elke 2 seconden herhaald vanwege de vertraging die wordt veroorzaakt door de functie sleep().

Om dit te doen, nemen we een leeg bestand met de extensie “.c” en voegen daar de headers “stdio.h” en “unistd.h” aan toe. Vervolgens openen we een lege functie main() en definiëren daarin de variabele seconden van het type int die we als teller voor de verstreken tijd zullen gebruiken.

Zodra de headers zijn ingevoegd en de variabele is gedeclareerd, openen we een oneindige lus en gebruiken we de printf()-functie daarin om het bericht en de tijdswaarde weer te geven. Op de volgende regel verhogen we de tijdvariabele met 2 en roepen vervolgens de functie sleep() aan met de waarde 2 als invoerargument. Op deze manier wordt deze cyclus elke seconde herhaald en krijgen we een teller die de verstreken tijd op het scherm weergeeft. Laten we nu eens kijken naar de code voor deze toepassing. Laten we de volledige code voor dit voorbeeld bekijken:

Hieronder zien we een afbeelding met de compilatie en uitvoering van deze code. Zoals we kunnen zien, drukt het programma elke 2 seconden de verstreken seconden op het scherm af sinds de uitvoering van het proces.

Effect van signalen op de slaap()-functie

In dit voorbeeld willen we het effect observeren van signalen op een proces dat in de slaapstand wordt gezet met behulp van de functie sleep(). Om dit te doen, maken we een eenvoudige applicatie die bestaat uit een main()-functie en een handler voor signaal 36.

In de eerste regel van de functie main() declareren we de resterende variabele van het type int, waar we de waarde opslaan die wordt geretourneerd door de functie sleep(). Vervolgens gebruiken we de functie signal() om de handler aan signaal 36 te binden. Op de volgende regel geven we de PID van het proces weer, die we vervolgens gebruiken om een ​​signaal van een tweede shell naar het proces te sturen. Ten slotte roepen we de functie sleep() aan en stellen we het invoerargument in op 60 seconden, lang genoeg om een ​​signaal vanuit een tweede shell te verzenden. We sturen de resterende variabele als uitvoerargument naar sleep().

De handler die aan signaal 36 is gekoppeld, bestaat uit een coderegel waarin de printf()-functie het bericht “Resterende tijd:” afdrukt, gevolgd door de waarde die wordt geretourneerd door sleep() op het moment dat het signaal bij het proces arriveert. Laten we hier eens kijken naar de code voor dit voorbeeld.

De volgende afbeelding die we zien toont de compilatie en uitvoering van deze code:

Om het effect van de signalen in dit proces te zien, compileren we deze code en voeren deze uit. Vervolgens sturen we vanaf een tweede terminal een signaal met de volgende syntaxis:

De volgende afbeelding die we zien toont de uitvoering van de code in de vorige console en de effecten van de aankomst van een signaal dat vanaf de volgende console wordt verzonden. Zoals je kunt zien, heeft het signaal het effect van de sleep()-functie onderdrukt door het proces wakker te maken:

Conclusie

In dit Linuxhint-artikel hebben we je laten zien hoe je de functie sleep() kunt gebruiken om een ​​proces gedurende een bepaald aantal seconden in de slaapstand te zetten. We hebben u ook de syntaxis laten zien, evenals de beschrijving van de functie en de aanroepmethode.

Met behulp van praktische voorbeelden, codefragmenten en afbeeldingen hebben we u laten zien hoe u een proces in de slaapstand kunt zetten en welke invloed de aankomst van een signaal heeft op een slaapproces met behulp van de functie sleep().