Gegroet, beste lezers van de webcodius blog! Laten we dus meteen ter zake komen. Eerst zal ik het tweede deel van de vraag beantwoorden: waarom zou het nodig kunnen zijn? meet de uitvoeringstijd van scripts?.Bij het werken aan het debuggen van webprojecten is de uitvoeringstijd van scripts een belangrijke factor waarmee rekening moet worden gehouden. Deze parameter is nodig om te begrijpen hoe snel en efficiënt een bepaald stuk code werkt. Door te bepalen hoeveel tijd de server besteedt aan het uitvoeren van een PHP-script, kunt u concluderen of code-optimalisatie nodig is of niet. Vervolgens bekijken we hoe we dit kunnen doen.

Om de prestaties van PHP-scripts te analyseren, zijn er verschillende extensies en bibliotheken, bijvoorbeeld XDebug, die scripts kunnen debuggen en deze kunnen profileren op basis van uitvoeringstijd. Maar om dergelijke extensies te gebruiken, moet u tijd besteden aan het installeren en configureren ervan. Om het werk van grote projecten met een complexe architectuur, een groot aantal scripts en miljoenen regels code te optimaliseren, is het natuurlijk beter om dergelijke extensies te gebruiken. Maar als u 3-4 scripts met één of tweehonderd regels code moet optimaliseren, kunt u alleen PHP-tools gebruiken om de looptijd van het script te meten.

Hoe de uitvoeringstijd van een script in php te bepalen

Dit probleem kan eenvoudig worden opgelost met behulp van functies voor het werken met datum en tijd, namelijk de ingebouwde functie microtime(), die het aantal seconden retourneert dat is verstreken sinds middernacht 01/01/1970. Door deze functie twee keer aan te roepen, kunnen we de verstreken tijd tussen oproepen berekenen:

Als u het script uitvoert, is het resultaat ongeveer zo:

Uitvoeringstijd van script: 0,00059400000000001

In het kort hoe het werkt. Met behulp van de functie microtime(true) slaan we de tijdstempel op toen het script begon te draaien in de variabele $start. Vervolgens komt de werkende code die enkele acties uitvoert. In dit voorbeeld wordt eenvoudigweg de functie usleep() aangeroepen, die het script gedurende een bepaald aantal microseconden vertraagt. En dan krijgen we de eindtijd van het script, slaan deze op in de $end variabele en berekenen de uitvoeringstijd van de code door $start af te trekken van $end . Als resultaat kregen we de uitvoeringstijd van het script.

Nu weten hoe te bepalen uitvoeringstijd van php-script, kunt u beginnen met het optimaliseren van verschillende codeblokken. Ik wens je veel succes en tot de volgende berichten!

Bij het debuggen van scripts is een verplichte factor waarmee eerst rekening moet worden gehouden uitvoeringstijd van het script. En in dit korte artikel zal ik een heel goede en eenvoudige manier laten zien, hoe u de uitvoeringstijd van een script kunt achterhalen.

Het is gebaseerd op functies voor het werken met datum en tijd. Ik stel voor dat u naar een voorbeeld kijkt, zodat u begrijpt hoe het gebeurt het berekenen van de uitvoeringstijd van het script:

$start = microtijd(waar);
$som = 0;
voor ($i = 0; $i< 100000; $i++) $sum += $i;
echo "Uitvoertijd script: ".(microtime(true) - $start);
?>

Als gevolg hiervan zullen we dat zien uitvoeringstijd van het script zal bijvoorbeeld zo zijn: " 0.014652967453 "Als je het naar boven afrondt, dan dit 0.015 seconden. Dit is de uitvoeringstijd van het script.

Laten we het nu hebben over hoe het werkt. Functie microtijd() met de doorgegeven waarde WAAR retourneert het aantal seconden sinds middernacht 01.01.1970 , en deze waarde wordt berekend tot honderdsten van een seconde.

Vervolgens komt het gebruikelijke script, dat we controleren. In plaats daarvan is er natuurlijk jouw script. En ten slotte toont de laatste regel het verschil tussen de huidige tijd (na het uitvoeren van het script) en wat we hebben opgenomen toen het script startte. Het verschil tussen de tijd nadat het script is uitgevoerd en de tijd voordat het begint te werken is uitvoeringstijd van het script.

Ik denk dat het hier eenvoudig is. Maar ik raad u ten zeerste aan deze methode voor het berekenen van de tijd te gebruiken. Toen ik bijvoorbeeld fouten opspoorde in het werk van mijn engine, waarop deze site zich bevindt, versnelde ik het werk ervan met bijna 2 keer.

Van de auteur: De zoon van mijn vriend raakte zo geïnteresseerd in scheikunde dat hij thuis verschillende ‘testen’ begon uit te voeren. Nadat de kroonluchter in de keuken hun ‘slachtoffer’ werd, vroeg zijn vader hem om zijn voorkeuren te veranderen. Als gevolg hiervan raakte het kind geïnteresseerd in statistieken en besloot het de gemiddelde brandtijd van één wedstrijd te berekenen. Het resultaat was dat het hele appartement bijna in brand vloog. Ik adviseerde de toekomstige wetenschapper om te beginnen met programmeren en de uitvoeringstijd van het PHP-script in te stellen.

Waarom meten bij programmeren?

In de eerste plaats is het veiliger dan scheikunde en statistiek. Maar in feite is de uitvoeringstijd van programmacode een belangrijke parameter die de prestaties van de gehele bron en de afzonderlijke modules ervan beïnvloedt. Er is meer vraag naar deze parameter tijdens optimalisatie en testen.

Laten we ons een beetje voorstellen. Laten we ons voorstellen dat er een soort "zelfgeschreven" engine is, die de ontwikkelaar naar een goede hosting heeft "geüpload" en (op basis daarvan) zijn website heeft gelanceerd. Maar om de een of andere reden is het laden van de bron aan de gebruikerskant erg traag.

In een dergelijke situatie zullen in eerste instantie alle hobbels op de host vallen. Hoogstwaarschijnlijk zal een boze programmeur een klacht indienen bij de hostingondersteuningsdienst. Ze zeggen dat de voorwaarden van het contract niet worden nageleefd, de site leeft nauwelijks...

Maar in feite kan het probleem van het langzaam laden van pagina's van een dynamische bron verborgen zijn in de engine zelf. En om er later niet als een “dummie” uit te zien, meet een ervaren ontwikkelaar altijd de uitvoeringstijd van een PHP-script voordat hij een project oplevert.

PHP-functies

Ik heb het altijd een van de handigste programmeertalen genoemd. Om de looptijd van de code bij te houden, hoeft de ontwikkelaar geen lange “talmoeds” te schrijven om elke regel van het script te onderscheppen. Deze technologie implementeert verschillende gespecialiseerde tools. De belangrijkste is de functie microtime(). Het retourneert de tijd (in milliseconden) die is verstreken sinds het begin van 1970. Het zogenaamde 'begin van het Unix-tijdperk'. Als u de parameter get_as_float doorgeeft aan de functie met de waarde true, retourneert deze de tijdsperiode in de vorm van hele seconden en fractionele milliseconden.

Het principe van het gebruik van microtime() is als volgt: de functie wordt aangeroepen aan het begin van het script en aan het einde ervan. Vervolgens wordt de beginwaarde afgetrokken van de laatste waarde. Zo berekent u de uitvoeringstijd van een script:

"; $last=microtime(true); $value=$last-$first; echo "Het script wordt uitgevoerd in: ".$value; ?>

De looptijd van de code wijzigen

In PHP kan de looptijd van het script programmatisch worden beperkt (verlagen of verhogen). Hiervoor worden verschillende functies gebruikt, die elk een parameterset in het configuratiebestand (php.ini) overschrijven.
Laten we eerst onze code aanpassen en het aantal lusiteraties twintig keer verhogen tot 200 miljoen. Als alles in orde is, zou u na het uitvoeren van het script een fatale foutmelding moeten ontvangen.

Dit betekent dat in de instellingen de parameter max_execution_time is ingesteld op de standaardwaarde (30 seconden). Laten we de maximale uitvoeringstijd van een script in PHP met 3 keer verhogen.

Nu krijgen we geen foutmeldingen.

Achtergronduitvoering van een script in PHP zonder crontab

• Website-ontwikkeling

Ik was verbaasd toen ik een daemon in PHP schreef. Die. een script dat bepaalde acties een bepaald aantal keren in een bepaald aantal uren op een willekeurig tijdstip (altijd willekeurig) zal uitvoeren, en dit alles zonder gebruik te maken van cron.

Ik had er nog nooit eerder last van gehad, maar nadat ik de taak had ingesteld, begon ik te denken dat dit onmogelijk was, dat het PHP-script door de browser moest worden aangeroepen... nou ja, de taak was ingesteld, hij moest worden voltooid.

De eerste gedachte is om de tijdslimiet voor het uitvoeren van scripts uit te schakelen. Verboden door de gastheer.

Het tweede idee is om het Ajax-verzoek periodiek (ja, minstens één keer per seconde) te herhalen met behulp van JavaScript. - niet mogelijk (klantbehoefte).

Het bleek in feite dat de browser niet open mocht zijn en cron niet mocht worden gebruikt, en dat het script voor onbepaalde tijd zou moeten werken, ongeacht de gebruiker. Uiteraard moet het systeem minimaal worden belast.

1. Een pakje sigaretten, nacht, Google, documenten, boeken, handleidingen….
ga naar 1…

Bij uitvoer krijg ik:
Taak_1:
Implementeer een scriptuitvoeringstijdgenerator op basis van het opgegeven aantal keren en aantal uren. Bewaar deze tijden ergens.

Taak_2:
Werk na het sluiten van de browser

Taak_3:
Crash niet nadat de tijdslimiet voor de uitvoering van het script is verstreken

Taak_4:
Voer bepaalde acties op het juiste moment uit.

Dus…
We schrijven de initiële gegevens in de configuratie:

Sessie_start(); // Start de sessie $num_starts = 120; // Aantal scriptuitvoeringen gedurende een bepaalde periode $hours = 1; // Aantal uren om het script $num_starts times uit te voeren. $time_sec = $uren*3600; // Aantal seconden in de opstartcyclus $time_to_start = array(); // Eigenlijk negeert een array met opstarttijden_user_abort(1); // Negeer verbindingsverlies met browser

Vervolgens schrijven we een functie waarmee we opstarttijden kunnen genereren.
Daarin genereren we een willekeurig getal van 0 tot het aantal seconden in het oorspronkelijke interval.
/****** * @desc Genereer het interval tussen lanceringen. */ function add_time2start() ( global $time_sec, $time_to_start; $new_time = time()+rand(0, $time_sec); if (!in_array($new_time, $time_to_start)) ( // Als zo'n tijd niet bestaat in de array - add $time_to_start = $new_time ) else ( add_time2start(); // Als een dergelijke tijd al bestaat, genereer deze dan opnieuw. ) )

$k = 1; if ($_SESSION["num_st"] == "" || $_SESSION["num_st"][$num_starts-1]< time()) { // проверка, что в сессию не записаны данные и что эти данные не устарели. do { add_time2start($k); $k++; } while ($k < = $num_starts); sort($time_to_start, SORT_NUMERIC); $_SESSION["num_st"] = $time_to_start; }

Nu moeten we het script laten uitvoeren, ongeacht de maximale uitvoeringstijd die door de server is ingesteld.
Het principe is:
1) Bepaal de starttijd van het script;
2) Bepaal de vastgestelde limiet voor de uitvoeringstijd.
3) We starten een lus, waarbinnen we de huidige tijd tellen en de totale looptijd van het script berekenen, de huidige tijd controleren met de waarden in de reeks starttijden, en als er een match is, voer dan de opgegeven acties (ik heb ze in het exec.php-bestand). We gebruiken sockets om bestanden uit te voeren.
4) Herhaal de cyclus totdat de looptijd van het script de maximaal toegestane tijd nadert. Ik stel het in totdat er nog 5 seconden over zijn tot de maximale tijd.

Dus... we berekenen de initiële tijdgegevens:

$start_time = microtijd(); // Ontdek de starttijd van het script $start_array = explode(" ",$start_time); // Afzonderlijke seconden en milliseconden $start_time = $start_array; // haal de starttijd van het script op $max_exec = ini_get("max_execution_time"); //Verkrijg de maximaal mogelijke looptijd van het script
Eigenlijk een cyclus. Opmerkingen in de code.

Do( $nowtime = time(); // Huidige tijd //// Als de huidige tijd in de array staat met de uitvoeringstijden van het script...... if (in_array($nowtime, $_SESSION["num_st"]) ) ( // We verbinden de socket met het bestand met de hoofdinhoud van de acties $http = fsockopen("test.ru",80); /// tegelijkertijd dragen we de sessiegegevens over en het tijdstip waarop deze zou fputs moeten werken($http, "GET http://test .ru/exec.php?".session_name()."=".session_id()."&nowtime=$nowtime HTTP/1.0\r\n"); fputs($http, "Host: test.ru\r\ n"); fclose($http ) //// heeft de opgegeven actie uitgevoerd // Ontdek het de huidige tijd om te controleren of de lus moet worden voortgezet of opnieuw moet worden gestart $now_time = microtime( ); $now_array = explode(" ",$now_time = $now_array; // trek de initiële tijd af van de huidige tijd $exec_time = $now_time - $start_time+$exec_time; /// een seconde langzamer usleep(1000000); // Een script stoppen dat op de achtergrond draait (file_exists("stop.txt" )) exit; //Controleer de looptijd, als er minder dan 5 seconden over zijn tot het einde van het script, beëindigen we de cyclus. ) while($exec_time< ($max_exec - 5));

Welnu, als de toegestane tijd ten einde loopt, voltooien we de cyclus en starten we hetzelfde script veilig in andere processen (we houden het zeker binnen 5 seconden)

// Start hetzelfde script als een nieuw proces en beëindig het huidige $http = fsockopen("test.ru",80); fputs($http, "Haal http://test.ru/index.php?".session_name()."=".session_id()."&bu=$max_exec HTTP/1.0\r\n"); fputs($http, "Host: test.ru\r\n"); fputs($http, "\r\n"); fclose($http);

Toen ik klaar was met het schrijven van alles, was ik verbaasd over de nuttige toepassing ervan... Je kunt het als een dienst gebruiken. Het kan iets op het netwerk monitoren en u bijvoorbeeld per e-mail op de hoogte stellen. En je hebt geen cron nodig.

Het script kan nog steeds worden geoptimaliseerd - ik heb geen wijzigingen aangebracht.
Trouwens, dit is waar ik mezelf niet van kon losmaken: je moet nog steeds de browser openen om het script in eerste instantie te starten.

Goede dag, collega's! 🙂

Vandaag besloot ik een onderwerp aan te snijden zoals de uitvoeringstijd van een PHP-script en de definitie ervan.

Ik zal niet zeggen dat deze behoefte elke dag ontstaat, maar in de praktijk doen zich van tijd tot tijd situaties voor waarin je de looptijd van een PHP-script nodig hebt.

Vooral vaak kun je ontwikkelaars betrappen die dit doen bij het refactoren van code en het optimaliseren van bestaande algoritmen, terwijl de uitvoeringstijd van een PHP-script een sleutelfactor is bij het kiezen van de uiteindelijke optie.

Nou ja, en soms zijn deze cijfers nodig voor managers en klanten die willen weten hoeveel tijd het kost voor een bepaalde actie in de code.

Daarom besloot ik deze korte notitie te schrijven, waarin ik besloot de procedure voor actie in een soortgelijke situatie te schetsen.

Eerst kijken we naar het algoritme zelf voor het bepalen van de uitvoeringstijd van een PHP-script, en daarna zorg ik voor de code waarmee het geïmplementeerd gaat worden.

Uitvoeringstijd van een PHP-script - bepalingsalgoritme

De procedure voor onze acties zal uiterst eenvoudig zijn:

1. bepaal de huidige servertijd in PHP-code voordat u de in het script gespecificeerde acties uitvoert;
2. nadat het script is uitgevoerd, ontdekken we opnieuw de servertijd;
3. Met behulp van PHP berekenen we het tijdsverschil tussen de voltooiing van de uitvoering van het script en de start ervan.

De resulterende waarde is de uitvoeringstijd van het PHP-script, waarmee rekening kan worden gehouden tijdens verdere optimalisatie en andere acties.

Looptijd van PHP-script - implementatie van algoritmen

Om de huidige tijd in PHP-code weer te geven, heb ik besloten de standaard PHP-functie te gebruiken microtijd(), dat de huidige tijdstempel in Unix-indeling retourneert met microseconden.

Waarom zo’n precisie?

Om vervolgens de kleinste veranderingen in de uitvoeringstijd van het script op te vangen, omdat soms kan een fractie van een seconde fataal zijn en grote verliezen veroorzaken bij het op grote schaal uitvoeren van langzame code.

En bovendien heeft het rekening houden met microseconden bij berekeningen invloed op de nauwkeurigheid van berekeningen in een positieve richting.

Om mijn theoretische verhalen te demonstreren, heb ik een eenvoudig script geschreven dat de looptijd van een lege lus berekent met 30.000.000 iteraties (ik besloot meer te nemen voor de duidelijkheid):

De PHP-microtime()-functie heeft slechts één parameter get_as_float, wanneer de waarden zijn opgegeven WAAR je kunt de huidige PHP-tijd in seconden sinds het Unix-tijdperk met microsecondenprecisie verkrijgen.

Omdat ik de huidige tijd nodig had, en niet het aantal seconden sinds het begin van het Unix-tijdperk, heb ik deze parameter gebruikt, die in mijn code te zien is.

Als gevolg hiervan wordt de functie gebruikt echo(), werd het volgende bericht op het scherm weergegeven: Het script werd uitgevoerd in 1,3156361579895 seconden.

Om vast te stellen of deze techniek correct werkte, besloot ik een vaste uitvoeringstijd in te stellen voor het script met behulp van de functie slaap(), waardoor de uitvoering van het script het opgegeven aantal seconden wordt vertraagd.

Als gevolg hiervan retourneerde de volgende constructie het bericht Het script werd uitgevoerd in 2.0000510215759 seconden:

Het overschrijden van de gespecificeerde vertraging met microscopisch kleine fracties van seconden kan worden toegeschreven aan de tijd die nodig is om codestructuren aan te roepen en de resultaten van hun uitvoering door de serverhardware te verwerken, zodat u ze volledig kunt negeren.

Als ze u of uw klant nog steeds irriteren, kunt u een hack gebruiken in de vorm van banale afronding op honderdsten of duizendsten met behulp van de PHP-functie round(), waarbij u deze als volgt gebruikt:

Round(microtime(true) - $start, 2);

Het resultaat van het uitvoeren van dit stukje code voor het bovenstaande voorbeeld zal een waarde van een nette 2 seconden zijn, wat geschikt is voor de meest geavanceerde perfectionisten :)

Dit is de conclusie van de informatie van vandaag over het bepalen van de uitvoeringstijd van een PHP-script.

Schrijf uw beoordelingen in de opmerkingen en stel alle vragen waarin u geïnteresseerd bent op de openbare pagina's van het project op sociale netwerken.