Πώς να μετρήσετε το χρόνο εκτέλεσης του σεναρίου στο php και γιατί είναι απαραίτητο

10 Φεβρουαρίου 2012 13 Κατηγορία:

Μερικές φορές θα πρέπει να δώσετε προσοχή λεπτομερώς στην ταχύτητα εκτέλεσης ενός σεναρίου (ή μέρος του σεναρίου), που δεν περιορίζεται στα σύντομα, εκπαιδευμένα μάτια σας. Αυτό είναι που τα χαρακτηριστικά γνωρίσματα της PHP για τη μέτρηση ταχύτητες λήψης έρχονται στη διάσωση. Μάλλον τα χρησιμοποιούσατε και γενικά ξέρετε πώς να το κάνετε. Αλλά μόνο σε περίπτωση, για εκείνους που δεν ξέρουν πώς να το κάνουν, καθώς και για την ενότητα "Σημαντικές μικροδουλειές", δημοσιεύω τον απλούστερο κώδικα που λύνει αυτό το ζήτημα.

$ start = microtime (true);
// body script
echo "Χρόνος εκτέλεσης δέσμης ενεργειών:" (microtime (true) - $ start).

Όλα είναι τρελά. Στην πρώτη γραμμή, δημιουργούμε μια μεταβλητή με μια ώρα έναρξης. Αυτό επιτυγχάνεται μέσω της λειτουργίας microtime   με την αλήθεια που πέρασε - αυτό σας επιτρέπει να πάρετε τον αριθμό των δευτερολέπτων με μεγάλο αριθμό δεκαδικών ψηφίων. Χρόνος, παρεμπιπτόντως, σε μορφή Unix.

Έπειτα έρχεται ολόκληρος ο κώδικας δέσμης ενεργειών, μετά τον οποίο, στην τρίτη γραμμή, αφαιρούμε από την τρέχουσα ώρα την έναρξη του σεναρίου και voila - έχετε τον χρόνο εκτέλεσης php script   Ακριβής με το σήμα μετά το σημείο.

Με άρεσε εδώ για να γράψω ένα δαίμονα στην PHP. Δηλαδή ένα σενάριο που θα δοθεί αρκετές φορές σε ένα συγκεκριμένο αριθμό ωρών σε τυχαίο χρόνο (πάντα τυχαίο) για να εκτελέσετε ορισμένες ενέργειες, όλες χωρίς τη χρήση του cron "a".

Δεν έχω ενοχλήσει ποτέ πριν, αλλά αφού έβαλα το έργο, άρχισα να σκέφτομαι ότι ήταν λάθος το php script να καλείται από το πρόγραμμα περιήγησης ... καλά, το έργο έχει ρυθμιστεί, πρέπει να γίνει.

Η πρώτη σκέψη είναι να απενεργοποιήσετε το χρονικό όριο εκτέλεσης δέσμης ενεργειών. Απαγορευμένη φιλοξενία.

Η δεύτερη σκέψη είναι να επαναλαμβάνουμε την αίτηση Ajax περιοδικά (ναι, τουλάχιστον μία φορά το δευτερόλεπτο). - είναι αδύνατο (η απαίτηση του πελάτη).

Στην πραγματικότητα αποδείχθηκε ότι το πρόγραμμα περιήγησης δεν πρέπει να είναι ανοιχτό και ότι το cron δεν μπορεί να χρησιμοποιηθεί και το σενάριο θα πρέπει να λειτουργεί ανεξάρτητα από το χρήστη επ 'αόριστον. Φυσικά, θα πρέπει τουλάχιστον να φορτώσει το σύστημα.

  1. Ένα πακέτο τσιγάρων, νύχτα, google, αποβάθρες, βιβλία, εγχειρίδια ....
  goto 1 ...

Στην έξοδο έχω:
  Εργασία_1:
  Εφαρμόστε τη γεννήτρια χρόνου εκτέλεσης δέσμης ενεργειών με βάση τον καθορισμένο αριθμό φορές και τον αριθμό ωρών. Κρατήστε κάπου αυτούς τους χρόνους.

Εργασία_2:
  Εργασία μετά το κλείσιμο του προγράμματος περιήγησης

Εργασία_3:
  Μην συντρίψετε μετά το τέλος του χρονικού ορίου δέσμης ενεργειών

Εργασία_4:
  Εκτελέστε κάποιες ενέργειες την κατάλληλη στιγμή.

Έτσι ...
Γράφουμε τα αρχικά δεδομένα στο config:

Session_start (); // Ξεκινήστε τη συνεδρία $ num_starts = 120; // Αριθμός σεναρίων ξεκινάει για ένα χρονικό διάστημα $ hours = 1; // Ο αριθμός των ωρών κατά τις οποίες πρέπει να εκτελέσετε το script $ num_starts φορές. $ time_sec = $ ώρες * 3600; // Ο αριθμός των δευτερολέπτων στον κύκλο εκτέλεσης $ time_to_start = array (); // Στην πραγματικότητα, ένας πίνακας με χρόνους έναρξης ignore_user_abort (1). // Παράβλεψη θραύσης του προγράμματος περιήγησης

Στη συνέχεια, γράψτε μια συνάρτηση που θα μας βοηθήσει να δημιουργήσουμε χρόνους εκτόξευσης.
  Σε αυτό, παράγουμε έναν τυχαίο αριθμό από το 0 στον αριθμό δευτερολέπτων στο αρχικό διάστημα.
  / ****** * @desc Δημιουργήστε το διάστημα μεταξύ των τρεξίματος. * / λειτουργία add_time2start () (global $ time_sec, $ time_to_start; $ new_time = time () + rand (0, $ time_sec); if (! in_array ($ new_time, $ time_to_start))) - προσθέστε $ time_to_start = $ new_time;) else (add_time2start (); // Αν υπάρχει ήδη τέτοιος χρόνος, δημιουργήστε ξανά.))

  $ k = 1; εάν ($ _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; }

Τώρα πρέπει να κάνουμε το σενάριο να δουλεύει, χωρίς προσοχή στο μέγιστο χρόνο εκτέλεσης που έχει οριστεί από το διακομιστή.
  Η αρχή είναι:
  1) Προσδιορίστε την ώρα έναρξης του σεναρίου.
  2) Καθορίζουμε το καθορισμένο όριο για το χρόνο εκτέλεσης.
  3) Ξεκινάμε τον κύκλο μέσα στον οποίο υπολογίζουμε την τρέχουσα ώρα και υπολογίζουμε τον χρόνο λειτουργίας του συνολικού script, ελέγξουμε την τρέχουσα ώρα με τις τιμές στη διάταξη χρόνου έναρξης και αν υπάρχει αντιστοιχία, εκτελέστε τις συγκεκριμένες ενέργειες (τις έχω στο αρχείο exec.php). Για να εκτελέσετε τις υποδοχές χρήσης αρχείων.
  4) Επαναλάβετε τον κύκλο μέχρι ο χρόνος εκτέλεσης του σεναρίου να είναι κοντά στο μέγιστο επιτρεπτό. Έχω ρυθμίσει - μέχρι ο μέγιστος χρόνος να είναι 5 δευτερόλεπτα.

Επομένως ... θεωρούμε τα αρχικά δεδομένα εγκαίρως:

  $ start_time = microtime (); // Ανακαλύψτε το χρόνο εκκίνησης του σεναρίου $ start_array = explode ("", $ start_time); // Ξεχωριστά δευτερόλεπτα και χιλιοστά του δευτερολέπτου $ start_time = $ start_array. // πάρτε την ώρα έναρξης του σεναρίου $ max_exec = ini_get ("max_execution_time"); // Πάρτε το μέγιστο πιθανή ώρα   εργασία σεναρίου
  Στην πραγματικότητα, ο κύκλος. Σχόλια στον κώδικα.

($ Nowtime = time (); // Current time //// Αν η τρέχουσα ώρα είναι σε πίνακα με χρόνο εκτέλεσης δέσμης ενεργειών ...... if (in_array ($ nowtime, $ _SESSION ["num_st"]))) ( // Με την υποδοχή που προσκολλάμε στο αρχείο με το κύριο περιεχόμενο των ενεργειών $ http = fsockopen ("test.ru", 80); /// ταυτόχρονα δίνουμε τα δεδομένα της συνεδρίας και την ώρα που θα πρέπει να ενεργοποιήσει τα fputs ($ http, "GET http: // test ($ http, "Host: test.ru \\ r \\ n"), "" και " ); $ now_array = εκραγεί ("", $ now_time); $ now_time = $ now_array; // εσύ να διαβάσει από την τρέχουσα ώρα, το αρχικό αρχικό $ exec_time = $ now_time - $ start_time + $ exec_time; /// φρένο για ένα δεύτερο usleep (1000000); // Σταματήστε το σενάριο να τρέχει στο παρασκήνιο. .txt ")) · // Ελέγξτε το χρόνο εκτέλεσης, εάν απομείνει λιγότερο από 5 δευτερόλεπτα μέχρι το τέλος του σεναρίου, τερματίστε τον κύκλο. ) ενώ ($ exec_time< ($max_exec - 5));

Λοιπόν, αν ο επιτρεπόμενος χρόνος τελειώσει, τότε τερματίζουμε τον κύκλο και τρέχουμε με ασφάλεια την ίδια σενάριο από την άλλη διαδικασία (σε 5 δευτερόλεπτα θα κρατήσουμε μέσα)

  // Εκτελέστε το ίδιο σενάριο με τη νέα διαδικασία και βγείτε από το τρέχον $ http = fsockopen ("test.ru", 80). fputs ($ http, "GET 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);

Όταν πρόσθεσα τα πάντα, ήμουν μπερδεμένος από μια χρήσιμη εφαρμογή ... Μπορείτε να το χρησιμοποιήσετε ως υπηρεσία. Μπορεί να παρακολουθεί κάτι στο δίκτυο και να σας ειδοποιεί, για παράδειγμα, μέσω ταχυδρομείου. Και δεν χρειάζεστε κανένα cron "s.

Το σενάριο μπορεί ακόμα να βελτιστοποιηθεί - δεν λειτούργησε στην αναθεώρηση.
  Παρεμπιπτόντως, αυτό δεν μπορούσα να αποκόψω από τον εαυτό μου - θα πρέπει να ανοίξει το πρόγραμμα περιήγησης για να τρέξει αρχικά το σενάριο.

Πόσο καιρό συνεχίζουν να λειτουργούν τα "βαριά" σενάρια, αν δεν περιμένουν το τέλος της δουλειάς τους να κλείσουν το πρόγραμμα περιήγησης; Και θα συνεχίσουν τη δουλειά τους; Όπως έδειξαν οι παρατηρήσεις, συνεχίζουν να ζουν προσπαθώντας να κάνουν το έργο που τους έχει ανατεθεί. Πολλοί για να ελέγξουν αυτό το είδος του χρόνου, η "σκοτεινή" ζωή των σεναρίων καταφεύγουν σε οδηγίες τύπου

ignore_user_abort (λειτουργία boolean)

Εάν αυτή η εντολή καλείται με ψευδής   παράμετρος, ισοδυναμεί με την απουσία της. Συνήθως ορίζεται με την παράμετρο αλήθεια - ignore_user_abort (true). Αυτό είναι απαραίτητο σε περιπτώσεις όπου πρέπει να συνεχίσετε να τρέχετε το σενάριο, ακόμα κι αν το πρόγραμμα περιήγησης έσπασε τη σύνδεση. Σε γενικές γραμμές, το php έχει τη δυνατότητα παρακολούθησης της κατάστασης σύνδεσης. Μου άρεσε η κατάσταση με τη συνέχιση του σεναρίου ακόμα και μετά το κλείσιμο του παραθύρου του προγράμματος περιήγησης. Είναι πολύ εύκολο να ελέγξετε: γράψτε ένα σενάριο που τρέχει για λίγο, ξεκινήστε το και κλείστε το παράθυρο του προγράμματος περιήγησης πριν περιμένετε να τελειώσει το σενάριο, μην ξεχάσετε να προσθέσετε ένα δείκτη τερματισμού στη δέσμη ενεργειών, για παράδειγμα, δημιουργήστε ένα αρχείο. Έτσι, μπορείτε να παρακολουθήσετε την απόδοση του σεναρίου σας. Σε γενικές γραμμές, μετά το κλείσιμο της συνόδου του πράκτορα (browser), το σενάριο θα πρέπει να πεθάνει, αλλά όπως μπορείτε να δείτε, αυτό δεν είναι έτσι: προσπαθεί ακόμα να ζήσει περισσότερο. Σε αυτή την περίπτωση, είναι λογικό να το μεταφέρουμε στην εκτέλεση φόντου (cron). Αλλά ήταν ακόμα ενδιαφέρον να αναλύσουμε αυτό το χαρακτηριστικό. Η εντολή χρησιμοποιείται για την παρακολούθηση της κατάστασης σύνδεσης. connection_status (). Για περαιτέρω χειρισμούς, γράφτηκαν τα περιτυλίγματα:

// κωδικός επιστροφής της κατάστασης σύνδεσης
λειτουργία getConnectStatus () (
  επιστροφή σύνδεσης_status ();
}

// επιστρέφει τον τύπο σύνδεσης κατά κωδικό
συνάρτηση getConnectStatusByCode ($ connectionStatus) (
  διακόπτης ($ connectionStatus) (
  περίπτωση CONNECTION_NORMAL:
  $ status = "Κανονική";
  σπάσει;
  περίπτωση CONNECTION_ABORTED:
  $ status = "Ακύρωση χρήστη";
  σπάσει;
  περίπτωση CONNECTION_TIMEOUT:

  $ status = "Υπέρβαση του μέγιστου χρόνου εκτέλεσης".
  σπάσει;
  περίπτωση (CONNECTION_ABORTED & CONNECTION_TIMEOUT):
  $ status = "Απορριμμένος και χρονομετρημένος";
  σπάσει;
  προεπιλογή:
  $ status = "Άγνωστο";
  σπάσει;
}
  επιστροφή $ status;
}

}

Τώρα μπορείτε να γράψετε μια λειτουργία που θα προσομοιώνει οποιαδήποτε μακρά εργασία

// απομιμήσεις μακρά δέσμη ενεργειών
λειτουργία scriptImitation () (

  $ start = χρόνος ();

  $ limitIteration = 1.000.000;
  για ($ i = 0; checkConnectionStatus () && ($ i< $limitIteration); $i++) {
  // κάποια μακρά εργασία ...
}

  $ end = time ();
  $ runtime = $ end - $ start?

Αν ($ i === $ limitIteration ||! CheckConnectionStatus ()) (
  $ connectStatus = getConnectStatusByCode (getConnectStatus ());
  $ scriptImitationLog = "Κατάσταση σύνδεσης: $ connectStatus";
  $ scriptImitationLog. = ";";
  $ scriptImitationLog. = "Εναλλαγή: $ i";
  $ scriptImitationLog. = ";";
  $ scriptImitationLog. = "Χρόνος εκτέλεσης: $ runTime δευτερόλεπτο";

Τα αρχεία_προκειμένων_αρχείων ("scriptImitationLog.txt", $ scriptImitationLog);
}

Στην πραγματικότητα, ξεκινάμε περιοδικά με τη διακοπή του έργου της γραφής μας. Ανεξάρτητα από το πόσο γρήγορα προσπάθησα να κλείσω το παράθυρο του πράκτορα, το σενάριο εξακολουθούσε να λειτουργεί επιτυχώς και δημιουργήθηκε ένα αρχείο καταγραφής στην έξοδο. Μην ξεχάσετε max_execution_time, περισσότερο από αυτή τη φορά το σενάριο απλά δεν θα ζήσει. Στην περίπτωσή μας, αυξήθηκε. Ας δούμε το ημερολόγιο:

Κατάσταση συνδέσμου: Κανονική; Επανάληψη: 1.000.000; Χρόνος εκτέλεσης: 5 δευτερόλεπτα

Όπως μπορείτε να δείτε, η σύνδεση είναι φυσιολογική, ο κύκλος έχει εργαστεί στο τέλος. Ποια είναι η συμφωνία; Σε αυτό το άρθρο stackoverflow   Βρήκα αυτή τη λύση εδώ - http://stackoverflow.com/questions/2389035/php-connection-status. Και συνδέθηκε με την προσωρινή μνήμη εξόδου: περιοδικά ένα μικρό μέρος δεδομένων (για παράδειγμα, ένας κενός χαρακτήρας) γράφεται στην προσωρινή μνήμη εξόδου του σεναρίου και στη συνέχεια επαναφέρεται (συνήθως σημαίνει php για να εξαναγκάσει ολόκληρο το περιεχόμενο να αποσταλεί και στη συνέχεια να διαγραφεί). Για το σκοπό αυτό, προτείνεται να χρησιμοποιηθεί η ανταλλαγή λειτουργιών. ob_flush   και flush. Και επειδή για επαναφορά, μια σύνδεση είναι υποδηλωμένη (το buffer σχηματίζεται για να σταλεί προς την κατεύθυνση του προγράμματος περιήγησης - εκκινητή), τότε στην επόμενη επαναφορά, εάν δεν υπάρχει κανονική σύνδεση, η κατάστασή του μεταφέρεται σε διαφορετική κατάσταση ( Ο χρήστης αποβλήθηκε). Και αν δεν υπάρχει εντολή στο σενάριο ή δίνεται στη φόρμα

ignore_user_abort (ψευδής);

Στη συνέχεια, όταν αλλάξει η κανονική κατάσταση σύνδεσης, το σενάριο διακόπτεται αμέσως, αν υπάρχει εντολή

ignore_user_abort (true);

Ακόμη και αν αλλάξει η κατάσταση της σύνδεσης, το σενάριο θα συνεχίσει να τρέχει μέχρι το τέλος, αλλά στην περίπτωση αυτή μπορεί να παρακολουθείται η κατάσταση της σύνδεσης. Έχοντας αυτό υπόψη, τροποποιούμε ελαφρώς ένα από τα περιτυλίγματα.

// Ελέγξτε την κατάσταση σύνδεσης (true - normal, false - abnormal)
λειτουργία checkConnectionStatus () (
  εκτύπωση "";
  ob_flush ();
  flush ();
  επιστροφή connection_status () === 0?
}

Τώρα όλα είναι υπό έλεγχο και σε περιπτώσεις που κλείνουμε το πρόγραμμα περιήγησης, το σενάριο θα διακοπεί ή θα οργανωθεί άλλη συμπεριφορά.
  Τέλος, θα δώσω τα αποτελέσματα μιας άλλης παρατήρησης. Αν συγκρίνετε τον χρόνο εκτέλεσης του σεναρίου στα αρχεία καταγραφής πριν κάνετε αλλαγές και αργότερα στο περιτύλιγμα - checkConnectionStatus,
  μπορούμε να συμπεράνουμε ότι η επαναφορά της προσωρινής μνήμης εξόδου απαιτεί πολύ χρόνο. Έτσι ο χρόνος για μια επανάληψη στο σενάριο δοκιμής χωρίς επαναφορά του buffer πήρε κατά μέσο όρο - 0,005 ms, με επαναφορά - 0,028 ms, δηλ. έλαβε ένα μέσο όρο buffer 0,023 msότι στο 4,6   φορές περισσότερες από μία επαναλήψεις. Αυτό δείχνει ότι η παραπάνω μέθοδος παρακολούθησης της ζωής του έργου των "βαριών" σεναρίων μπορεί να αυξήσει τον κύριο χρόνο. Αυτή η δοκιμή εκτελέστηκε στο Firefox έκδοση 29.0.1. Όλη η επιτυχία.

Σε οποιοδήποτε διακομιστή διακομιστή λειτουργεί το σενάριό σας, αλλά το πρόβλημα της ταχύτητάς του αφορά όλους. Το φορτίο του διακομιστή εξαρτάται και από αυτό (σε κάποια δωρεάν φιλοξενία, ένα συγκεκριμένο χρονικό διάστημα του επεξεργαστή ανά μήνα) και ο χρόνος μετά τον οποίο ο χρήστης αρχίζει να εμφανίζει τον ιστότοπο (και οι σύγχρονοι χρήστες είναι πολύ επικριτικοί ως προς τον χρόνο φόρτωσης του ιστότοπου).

  Αυτή η ίδια ταχύτητα μπορεί να καθοριστεί πολύ απλά με τη λειτουργία microtime ().
  Από προεπιλογή, η συνάρτηση επιστρέφει μια συμβολοσειρά με τη μορφή "msec sec", όπου sec είναι ο αριθμός δευτερολέπτων από την αρχή της περιόδου Unix (The Unix Epoch, 1 Ιανουαρίου 1970, 00:00:00 GMT) και msec είναι το κλασματικό μέρος.
  Αλλά αν η λειτουργία ονομάζεται με την προαιρετική παράμετρο microtime ([bool $ get_as_float]), με την προϋπόθεση ότι το όρισμα που έχει περάσει   get_as_float   , είναι TRUE ή 1, επιστρέφει έναν πραγματικό αριθμό, δηλαδή:

Echo microtime (); // θα πάμε 0.79687900 1234083984 echo microtime (0); // παίρνουμε 0.79687900 1234083984 echo microtime (ψευδής); // παίρνουμε 0.79687900 1234083984 echo microtime (1); // παίρνουμε 1234083984.79 echo microtime (true); // θα λάβουμε 1234083984.79
  Από αυτό προκύπτει ότι έχοντας γράψει την ακόλουθη γραμμή στην αρχή του php script:
  $ time_start_script = microtime (1);
  και στο τέλος του σεναρίου:
  $ time_stop_script = microtime (1); $ time_script_work = $ time_stop_script - $ time_start_script; echo $ time_script_work;

παίρνουμε το χρόνο εκτέλεσης του σεναρίου, το οποίο είναι αρκετό για να αξιολογήσει επαρκώς την ταχύτητα εκτέλεσης του.

Λοιπόν, αν θυμάστε το "ποδήλατο", μπορείτε να πάρετε χρόνο με ακρίβεια έως και 10-15 δεκαδικών ψηφίων (τουλάχιστον έκανα τόσο πολύ ανάλογα με το χρόνο εκτέλεσης του σεναρίου), αλλά αυτό θα έχει μεγαλύτερη επίδραση στο χρόνο εκτέλεσης του σεναρίου σε αντίθεση με το παραπάνω παράδειγμα, αλλά θα μάθετε για ένα άλλο χρήσιμο χαρακτηριστικό.
  Ας γράψουμε μια γραμμή στην αρχή της δέσμης ενεργειών php:
  $ time_start_script = microtime (); $ time_start_script = εκραγεί ("", $ time_start_script); $ time_start_script = $ time_start_script ["0"] + $ time_start_script ["1"];
  και στο τέλος του σεναρίου:
  $ time_stop_script = microtime (); $ time_stop_script = εκραγεί ("", $ time_stop_script); $ time_stop_script = $ time_stop_script ["0"] + $ time_stop_script ["1"]; $ time_script_work = $ time_stop_script - $ time_start_script; echo $ time_script_work. "sec";
  Αυτό το παράδειγμα έφερε στην περίπτωσή μου 0.000353097915649 sec.
  Τώρα ας δούμε τι είναι αυτή η περίεργη λειτουργία έκρηξης ().
  array έκρηξη (string $ separator, συμβολοσειρά $ string [, int $ limit])
Η συνάρτηση επιστρέφει μια σειρά από συμβολοσειρές που προκύπτουν διαιρώντας τη συμβολοσειρά συμβολοσειρών χρησιμοποιώντας διαχωριστικό ως διαχωριστικό. Αν το όριο ορίου είναι δεδομένο, ο πίνακας θα περιέχει ένα μέγιστο των οριακών στοιχείων, με το τελευταίο στοιχείο να περιέχει το υπόλοιπο της συμβολοσειράς.
  Αν ο διαχωριστής είναι κενή συμβολοσειρά (""), η έκρηξη () επιστρέφει FALSE. Αν ο διαχωριστής δεν περιέχεται σε συμβολοσειρά, τότε η έκρηξη () επιστρέφει μια συστοιχία που περιέχει ένα στοιχείο στοιχειοσειράς.
  Παράδειγμα χρήσης: $ pizza = "piece1 piece2 piece3 piece4 piece5 piece6"; $ pieces = εκραγεί ("", $ πίτσα); echo $ pieces; // piece1 echo $ pieces; // piece2
  Αυτό είναι βασικά όλα. Τώρα μπορείτε να υπολογίσετε την ταχύτητα των σεναρίων που έχετε γράψει.
  Το συνημμένο αρχείο περιέχει τους πηγαίους κώδικες των σεναρίων που παρατίθενται εδώ, ενώ για να λειτουργήσει το σενάριο περισσότερο, περιέχει ένα κενό βρόχο, ο οποίος εκτελείται εκατομμύρια φορές :).
  Καλή τύχη!

Καλώς ήλθατε, αγαπητοί αναγνώστες του ιστολογίου webcodius! Έτσι, αμέσως στο σημείο. Πρώτον, θα απαντήσω στο δεύτερο μέρος της ερώτησης: γιατί θα ήταν απαραίτητο; μέτρηση χρόνου εκτέλεσης δέσμης ενεργειών• Όταν εργάζεστε σε προγράμματα web debugging, ένας σημαντικός παράγοντας που πρέπει να ληφθεί υπόψη είναι ο χρόνος εκτέλεσης των σεναρίων. Αυτή η παράμετρος είναι απαραίτητη για να κατανοήσουμε πόσο γρήγορα και αποτελεσματικά το συγκεκριμένο κομμάτι κώδικα λειτουργεί. Έχοντας καθορίσει το χρόνο που πέρασε ο διακομιστής run php   script, μπορείτε να καταλήξετε: εάν απαιτείται βελτιστοποίηση κώδικα ή όχι. Στη συνέχεια, σκεφτείτε πώς να το κάνετε.

Για να αναλύσετε την απόδοση των σεναρίων php, υπάρχουν διάφορες επεκτάσεις και βιβλιοθήκες, όπως το XDebug, το οποίο μπορεί να εντοπίσει σφάλματα σε δέσμες ενεργειών και να τους προφίλ με βάση το χρόνο εκτέλεσης. Αλλά για να χρησιμοποιήσετε αυτές τις επεκτάσεις, θα πρέπει να αφιερώσετε χρόνο εγκαθιστώντας και διαμορφώνοντας τους. Φυσικά, για να βελτιστοποιήσετε το έργο μεγάλων έργων με σόλο αρχιτεκτονική, μεγάλο αριθμό σεναρίων και εκατομμυρίων γραμμών κώδικα, είναι καλύτερο να χρησιμοποιήσετε αυτές τις επεκτάσεις. Αλλά αν χρειαστεί να βελτιστοποιήσετε 3-4 σενάρια με μία ή δύο εκατοντάδες γραμμές κώδικα, τότε μπορείτε να χρησιμοποιήσετε τα εργαλεία php για να μετρήσετε το runtime script.

Πώς να καθορίσετε το χρόνο εκτέλεσης δέσμης ενεργειών στο php

Μάθετε να δημιουργείτε επαγγελματίες κινητήρες σε PHP και MySQL

Αυτή η εργασία επιλύεται εύκολα με τη βοήθεια λειτουργιών για εργασία με ημερομηνία και ώρα, δηλαδή την ενσωματωμένη λειτουργία microtime (), η οποία επιστρέφει τον αριθμό δευτερολέπτων από τα μεσάνυχτα της 01/01/1970. Καλώντας τη λειτουργία αυτή δύο φορές, μπορούμε να υπολογίσουμε το χρόνο που έχει περάσει μεταξύ των κλήσεων:

Αν εκτελέσετε το σενάριο, το αποτέλεσμα θα είναι κάτι τέτοιο:

Χρόνος εκτέλεσης δέσμης ενεργειών: 0.00059400000000001

Εν συντομία, πώς λειτουργεί. Χρησιμοποιώντας τη λειτουργία microtime (true), απομνημονεύουμε την ώρα έναρξης του σεναρίου στη μεταβλητή $ start. Επόμενος είναι ο κώδικας εργασίας που εκτελεί ορισμένες ενέργειες. Σε αυτό το παράδειγμα, η λειτουργία usleep () καλείται απλά, η οποία επιβραδύνει τη δέσμη ενεργειών για ένα συγκεκριμένο αριθμό μικροδευτερολέπτων. Και έπειτα παίρνουμε την ώρα λήξης του σεναρίου, το αποθηκεύουμε στη μεταβλητή end $ και υπολογίζουμε τον χρόνο εκτέλεσης κώδικα αφαιρώντας το $ start από το $ end. Ως αποτέλεσμα, πήρε το χρόνο εκτέλεσης του σεναρίου.

Τώρα γνωρίζοντας πώς να ορίσετε το php εκτέλεσης δέσμης ενεργειών, μπορείτε να ξεκινήσετε τη βελτιστοποίηση διαφορετικών μπλοκ κώδικα. Καλή τύχη και να σας δω στις επόμενες θέσεις!