Πώς να μάθετε το χρόνο εκτέλεσης δέσμης ενεργειών στην PHP. Χρόνος εκτέλεσης δέσμης ενεργειών PHP
Σε οποιοδήποτε διακομιστή διακομιστή λειτουργεί το σενάριό σας, αλλά το πρόβλημα της ταχύτητάς του αφορά όλους. Το φορτίο στο διακομιστή εξαρτάται από αυτό (σε κάποια δωρεάν φιλοξενία, ένα συγκεκριμένο χρονικό διάστημα του επεξεργαστή ανά μήνα) και ο χρόνος μετά τον οποίο ο χρήστης αρχίζει να εμφανίζει τον ιστότοπο (και οι σύγχρονοι χρήστες είναι πολύ επικριτικοί για το χρόνο φόρτωσης του ιστότοπου).
Αυτή η ταχύτητα μπορεί να καθοριστεί πολύ απλά με τη λειτουργία 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 = μικρό χρόνο (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 = εκραγεί ("", $ pizza); echo $ pieces; // piece1 echo $ pieces; // κομμάτι2
Αυτό είναι βασικά όλα. Τώρα μπορείτε να αξιολογήσετε την ταχύτητα των σεναρίων που έχετε γράψει.
Το συνημμένο αρχείο περιέχει τους πηγαίους κώδικες των σεναρίων που παρατίθενται εδώ, ενώ για να λειτουργήσει το σενάριο περισσότερο, περιέχει ένα κενό βρόχο, ο οποίος εκτελείται εκατομμύρια φορές :).
Καλή τύχη!
10 Φεβρουαρίου 2012 13 Κατηγορία:
Μερικές φορές πρέπει να δώσετε προσοχή στη λεπτομέρεια στην ταχύτητα εκτέλεσης ενός σεναρίου (ή μέρος του σεναρίου), που δεν περιορίζεται στα σύντομα, εκπαιδευμένα μάτια σας. Αυτό συμβαίνει όταν οι δυνατότητες της PHP για τη μέτρηση της ταχύτητας λήψης έρχονται στη διάσωση. Πιθανότατα τα χρησιμοποιούσατε και γενικά ξέρετε πώς να το κάνετε. Αλλά για κάθε περίπτωση, για εκείνους που δεν ξέρουν πώς να το κάνουν, καθώς και για την ενότητα "Σημαντικές μικροδουλειές", δημοσιεύω τον απλούστερο κώδικα που λύνει αυτό το ζήτημα.
$ start = microtime (true);
// body script
echo "Χρόνος εκτέλεσης δέσμης ενεργειών:" (microtime (true) - $ start) "sec";
Όλα είναι τρελά. Στην πρώτη γραμμή, δημιουργούμε μια μεταβλητή με μια ώρα έναρξης. Αυτό επιτυγχάνεται μέσω της λειτουργίας microtime με την αλήθεια που πέρασε - αυτό σας επιτρέπει να πάρετε τον αριθμό των δευτερολέπτων με μεγάλο αριθμό δεκαδικών ψηφίων. Χρόνος, παρεμπιπτόντως, σε μορφή Unix.
Στη συνέχεια έρχεται ολόκληρος ο κώδικας δέσμης ενεργειών, μετά τον οποίο, στην τρίτη γραμμή, αφαιρούμε από την τρέχουσα ώρα την έναρξη του σεναρίου και το voila - έχετε το χρόνο να εκτελέσετε το σενάριο php με την ακρίβεια του δεκαδικού σημείου.
Πόσο καιρό συνεχίζουν να λειτουργούν τα "βαριά" σενάρια, αν δεν περιμένουν το τέλος της δουλειάς τους να κλείσουν το πρόγραμμα περιήγησης; Και θα συνεχίσουν τη δουλειά τους; Όπως έδειξαν οι παρατηρήσεις, συνεχίζουν να ζουν προσπαθώντας να εκτελέσουν το έργο που τους έχει ανατεθεί. Πολλοί για να ελέγξουν αυτό το είδος του χρόνου, η "σκοτεινή" ζωή των σεναρίων καταλήγει σε οδηγίες τύπου
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. Όλη η επιτυχία.
Κατά τη διαδικασία εντοπισμού σφαλμάτων, ένας υποχρεωτικός παράγοντας που πρέπει να εξεταστεί καταρχήν είναι χρόνο εκτέλεσης δέσμης ενεργειών. Και σε αυτό το σύντομο άρθρο θα σας δείξω έναν πολύ καλό και εύκολο τρόπο. πώς να μάθετε το χρόνο εκτέλεσης δέσμης ενεργειών.
Βασίζεται σε λειτουργίες για εργασία με ημερομηνία και ώρα. Προτείνω να εξετάσετε ένα παράδειγμα για να καταλάβετε πώς συμβαίνει αυτό. Χρόνος εκτέλεσης δέσμης ενεργειών:
$ start = microtime (true);
$ sum = 0;
για ($ i = 0; $ i< 100000; $i++) $sum += $i;
echo "Χρόνος εκτέλεσης δέσμης ενεργειών:" (microtime (true) - $ start);
?>
Ως αποτέλεσμα, θα το δούμε χρόνο εκτέλεσης δέσμης ενεργειών για παράδειγμα, θα είναι: " 0.014652967453 "Αν το στρογγυλοποιήσετε, τότε αυτό 0.015 δευτερολέπτων Αυτός είναι ο χρόνος εκτέλεσης του σεναρίου.
Τώρα πώς λειτουργεί. Λειτουργία microtime () με μεταδιδόμενη τιμή αλήθεια επιστρέφει τον αριθμό των δευτερολέπτων από τα μεσάνυχτα 01.01.1970 , και αυτή η τιμή υπολογίζεται σε εκατοστά του δευτερολέπτου.
Ακολουθεί το συνηθισμένο σενάριο, το οποίο ελέγξαμε. Αντ 'αυτού, σίγουρα θα είναι το σενάριό σας. Και τέλος, η τελευταία γραμμή είναι η διαφορά μεταξύ της τρέχουσας ώρας (μετά την εκτέλεση του σεναρίου) και του τι καταγράψαμε στην αρχή του σεναρίου. Η διαφορά χρόνου μετά την εκτέλεση του σεναρίου και ο χρόνος πριν ξεκινήσει, και υπάρχει χρόνο εκτέλεσης δέσμης ενεργειών.
Νομίζω ότι όλα είναι απλά εδώ. Αλλά συνιστώ να χρησιμοποιήσετε αυτή τη μέθοδο υπολογισμού του χρόνου. Για παράδειγμα, όταν έκανα εντοπισμό των εργασιών του κινητήρα μου, στον οποίο βρίσκεται αυτή η τοποθεσία, εγώ άπλωσα το έργο του σχεδόν μέσα 2 φορές
Ανεξάρτητα από το πόσο χρησιμοποιούμε την PHP, μερικές λειτουργίες εξακολουθούν να εμφανίζονται και δεν έχουμε ακούσει καν. Ορισμένες από αυτές θα ήταν πολύ χρήσιμες για εμάς. Δημιούργησα μια μικρή λίστα με χρήσιμες λειτουργίες που πρέπει να βρίσκονται στο οπλοστάσιο κάθε προγραμματιστή PHP.
1. Δημιουργία λειτουργιών με μεταβλητό αριθμό επιχειρημάτων
Πιθανότατα, γνωρίζετε ήδη ότι η PHP μας επιτρέπει να δημιουργούμε λειτουργίες με προαιρετικά επιχειρήματα. Τώρα θα δείξω μια λειτουργία στην οποία ο αριθμός των επιχειρημάτων μπορεί να διαφέρει από περίπτωση σε περίπτωση.
Αλλά πρώτα, ας θυμηθούμε πώς δημιουργούμε τις λειτουργίες με τον συνήθη τρόπο:
// λειτουργία με δύο προαιρετικές παραμέτρους συνάρτηση foo ($ arg1 = "", $ arg2 = "") (echo "arg1: $ arg1 \\ n"; echo "arg2: $ arg2 \\ n";) foo "κόσμος")? / * θα εξάγει: arg1: hello arg2: world * / foo (); / * θα εξάγει: arg1: arg2: * /
Τώρα ας δούμε πώς μπορείτε να γράψετε μια λειτουργία με απεριόριστο αριθμό επιχειρημάτων. Για να το κάνετε αυτό, χρησιμοποιήστε τη μέθοδο func_get_args ():
// δεν καθορίζουμε τα επιχειρήματα function foo () (// επιστρέφει μια σειρά από τα επιχειρήματα που περάσαμε $ args = func_get_args (); foreach ($ args ως $ k =\u003e $ v) (echo "arg". : $ v \\ n ";)) foo (); / * δεν θα δώσει τίποτα * / foo ("hello"); / * εκτυπώσεις arg1: hello * / foo ("γεια", "κόσμος", "πάλι"); / * θα εκτυπώσει arg1: hello arg2: world arg3: πάλι * /
2. Χρησιμοποιήστε το Glob () για αναζήτηση αρχείων.
Συχνά τα ονόματα των λειτουργιών μιλούν από μόνα τους. Αυτό δεν μπορεί να ειπωθεί για τη συνάρτηση glob ().
Χωρίς λεπτομέρειες, η λειτουργικότητά του είναι παρόμοια με τη μέθοδο scandir (). Σας επιτρέπει να βρείτε απαιτούμενο αρχείο κατά πρότυπο:
// βρείτε όλα τα php αρχεία $ files = glob ("*. php"); print_r ($ αρχεία); / * θα εξάγει: Array (=\u003e phptest.php =\u003e pi.php =\u003e post_output.php =\u003e test.php) * /
Για να βρείτε αρχεία διαφόρων τύπων, γράψτε τα εξής:
// βρείτε όλα τα αρχεία php και txt $ files = glob ("*. (php, txt)", GLOB_BRACE); print_r ($ αρχεία); / * εξόδου: Αρχείο (=\u003e phptest.php =\u003e pi.php =\u003e post_output.php =\u003e test.php =\u003e log.txt =\u003e test.txt) * /
Μπορείτε επίσης να καθορίσετε τη διαδρομή στο πρότυπο:
$ files = σφαίρα ("../ images / a * .jpg"); print_r ($ αρχεία); / * εξόδου: Array (=\u003e ../images/apple.jpg =\u003e ../images/art.jpg) * /
Για να πάρετε την πλήρη διαδρομή στο έγγραφο, χρησιμοποιήστε τη μέθοδο realpath ():
$ files = σφαίρα ("../ images / a * .jpg"); // Εφαρμόστε τη συνάρτηση "realpath" σε κάθε στοιχείο του πίνακα $ files = array_map ("realpath", $ files). print_r ($ αρχεία); / * εμφανίζει: Array (=\u003e C: \\ wamp \\ www \\ images \\ apple.jpg =\u003e C: \\ wamp \\ www \\ images \\ art.jpg)
3. Πληροφορίες σχετικά με τη μνήμη που χρησιμοποιήσατε
Εάν παρακολουθείτε την ποσότητα μνήμης που καταναλώνεται από τη δουλειά των σεναρίων σας, πιθανότατα θα τις βελτιστοποιήσετε συχνότερα.
Υπάρχει ένα ισχυρό εργαλείο εντοπισμού μνήμης στην PHP. Σε διαφορετικά μέρη του σεναρίου, το φορτίο μπορεί να είναι διαφορετικό. Προκειμένου να χρησιμοποιηθεί αυτή τη στιγμή η αξία της μνήμης, πρέπει να χρησιμοποιήσουμε τη μέθοδο memory_get_usage (). Για τον καθορισμό της μέγιστης χρησιμοποιούμενης μνήμης memory_get_peak_usage ()
Echo "Αρχικό:" .memory_get_usage () "Bytes \\ n"; / * Αρχικό: 361400 bytes * / // δίνουν ένα μικρό φορτίο για ($ i = 0; $ i< 100000; $i++) { $array = md5($i); } // и ещё for ($i = 0; $i < 100000; $i++) { unset($array[$i]); } echo "Final: ".memory_get_usage()." bytes \n"; /* Final: 885912 bytes */ echo "Peak: ".memory_get_peak_usage()." bytes \n"; /* Peak: 13687072 bytes */
4. Πληροφορίες επεξεργαστή
Για να το κάνετε αυτό, χρησιμοποιήστε τη μέθοδο getrusage (). Σημειώστε ότι αυτή η λειτουργία δεν θα λειτουργήσει στα Windows.
Print_r (getrusage ()); / * εκτυπώνει το Array (=\u003e 0 =\u003e 0 =\u003e 2 =\u003e 3 =\u003e 12692 =\u003e 764 =\u003e 3864 =\u003e 94 =\u003e 0 =\u003e 1 =\u003e 67 =\u003e 4 =\u003e 0 =\u003e 0 =\u003e 0 =\u003e 6269 =\u003e 0) * /
Η εικόνα που περιγράφεται παραπάνω θα είναι σαφής σε όσους έχουν εμπειρία στη διαχείριση του συστήματος. Για όλους τους άλλους προσφέρουμε αποκωδικοποίηση:
- ru_oublock: ο αριθμός των λειτουργιών εγγραφής μπλοκ
- ru_inblock: ο αριθμός των λειτουργιών ανάγνωσης μπλοκ
- ru_msgsnd: ο αριθμός των απεσταλμένων μηνυμάτων
- ru_msgrcv: αριθμός ληφθέντων μηνυμάτων
- ru_maxrss: το μέγιστο μέγεθος ενός μη σελιδοποιημένου συνόλου
- ru_ixrss: συνολική κοινή μνήμη
- ru_idrss: συνολικός αριθμός μη κοινόχρηστων δεδομένων
- ru_minflt: ο αριθμός των σελίδων μνήμης που χρησιμοποιήθηκαν
- ru_majflt: αριθμός σφαλμάτων που λείπουν από τη σελίδα
- ru_nsignals: ο αριθμός των λαμβανόμενων σημάτων
- ru_nvcsw: αριθμός διακόπτων περιβάλλοντος κατά διαδικασία
- ru_nivcsw: ο αριθμός των forced forced switches
- ru_nswap: ο αριθμός των προσπελάσεων στο δίσκο κατά την τηλεειδοποίηση
- ru_utime.tv_usec: χρόνος λειτουργίας χρήστη (μικροδευτερόλεπτα)
- ru_utime.tv_sec: τρόπος χρήστη (δευτερόλεπτα)
- ru_stime.tv_usec: χρόνος λειτουργίας σε προνομιακή λειτουργία (μικροδευτερόλεπτα)
- ru_stime.tv_sec: ώρα σε προνομιακή λειτουργία (δευτερόλεπτα)
Για να μάθετε ποιοι πόροι χρησιμοποιεί ο επεξεργαστής τη δέσμη ενεργειών, χρειάζεστε την τιμή του 'χρόνου χρήστη' (ώρα σε κατάσταση χρήστη) και του 'χρόνου συστήματος' (ώρα σε προνομιακή λειτουργία). Μπορείτε να πάρετε το αποτέλεσμα σε δευτερόλεπτα και σε μικροδευτερόλεπτα. Για να μετατρέψετε τον συνολικό αριθμό δευτερολέπτων σε δεκαδικό αριθμό, πρέπει να διαιρέσετε την τιμή του μικροδευτερολέπτου κατά 1 εκατομμύριο και να την προσθέσετε στη δεύτερη τιμή.
Μπερδεμένος με κάποιο τρόπο. Ακολουθεί ένα παράδειγμα:
// υπόλοιπο 3 δευτερολέπτων ύπνος (3); $ data = getrusage (); echo "Χρόνος χρήστη:". ($ δεδομένα ["en_utime.tv_sec"] + $ δεδομένα ["en_utime.tv_usec"] / 1.000.000). echo "Χρόνος συστήματος:". ($ δεδομένα ["ru_stime.tv_sec"] + $ δεδομένα ["ru_stime.tv_usec"] / 1.000.000). / * εμφανίζει Χρόνος χρήστη: 0.011552 Χρόνος συστήματος: 0 * /
Αν και το σενάριο χρειάστηκε περίπου 3 δευτερόλεπτα για να ολοκληρωθεί, ο επεξεργαστής δεν φορτώθηκε βαριά. Το γεγονός είναι ότι όταν καλείτε (ύπνος), το σενάριο καταναλώνει σχεδόν καθόλου πόρους CPU. Γενικά, υπάρχουν πολλά καθήκοντα που χρειάζονται σημαντικό χρόνο, αλλά δεν χρησιμοποιούν επεξεργαστή. Για παράδειγμα, περιμένετε για λειτουργίες που σχετίζονται με το δίσκο. Επομένως, δεν χρησιμοποιείτε πάντα χρόνο CPU στα σενάρια σας.
Ακολουθεί ένα άλλο παράδειγμα:
// περπατήστε 10 εκατομμύρια φορές για ($ i = 0; $ i<10000000;$i++) { } $data = getrusage(); echo "User time: ". ($data["ru_utime.tv_sec"] + $data["ru_utime.tv_usec"] / 1000000); echo "System time: ". ($data["ru_stime.tv_sec"] + $data["ru_stime.tv_usec"] / 1000000); /* выводит User time: 1.424592 System time: 0.004204 */
Το σενάριο πήρε 1,4 δευτερόλεπτα χρόνου CPU. Σε αυτήν την περίπτωση, ο χρόνος κλήσης συστήματος είναι γενικά χαμηλός.
Ο χρόνος λειτουργίας στην προνομιακή λειτουργία (System Time) είναι ο χρόνος που ο επεξεργαστής δαπανά για την εκτέλεση αιτημάτων συστήματος στον πυρήνα για λογαριασμό του προγράμματος. Παράδειγμα:
$ start = microtime (true); // κλήση microtime κάθε 3 δευτερόλεπτα ενώ (microtime (true) - $ start< 3) { } $data = getrusage(); echo "User time: ". ($data["ru_utime.tv_sec"] + $data["ru_utime.tv_usec"] / 1000000); echo "System time: ". ($data["ru_stime.tv_sec"] + $data["ru_stime.tv_usec"] / 1000000); /* выводит User time: 1.088171 System time: 1.675315 */
Τώρα ο χρόνος του συστήματος δαπανήθηκε πολύ περισσότερο από ό, τι στο προηγούμενο παράδειγμα. Όλα χάρη στη μέθοδο microtime (), η οποία χρησιμοποιεί πόρους συστήματος.
Ωστόσο, πρέπει να σημειωθεί ότι ο χρόνος που εμφανίζεται μπορεί να μην είναι ακριβής, επειδή Σε αυτή τη χρονική στιγμή, οι πόροι CPU χρησιμοποιούνται από άλλα προγράμματα, γεγονός που μπορεί να οδηγήσει σε ένα μικρό σφάλμα.
5. Μαγικές σταθερές
Στην PHP, υπάρχουν πολλές μαγικές σταθερές, όπως η τρέχουσα αριθμό γραμμής (__LINE__), διαδρομή αρχείου (__FILE__), διαδρομή καταλόγου (__DIR__), το όνομα της συνάρτησης (__FUNCTION__), το όνομα της κλάσης (__CLASS__), το όνομα μέθοδο (__METHOD__) και namespaces (__NAMESPACE__).
Όλοι δεν θα τις εξετάσουμε. Ας δούμε μόνο ένα ζευγάρι:
// Αυτή η δέσμη ενεργειών εξαρτάται από την τρέχουσα θέση του αρχείου και // μπορεί να προκαλέσει προβλήματα αν χρησιμοποιείται από διαφορετικούς καταλόγους. // αυτό το σενάριο δεν θα προκαλέσει προβλήματα requ_once (dirname (__ FILE__). /config/database.php ");
Χρησιμοποιήστε το __LINE__ κατά τη δημιουργία εντολών εντοπισμού σφαλμάτων:
// code // ... my_debug ("κάποιο μήνυμα εντοπισμού σφαλμάτων", __LINE__); / * θα εξάγει Γραμμή 4: κάποιο μήνυμα εντοπισμού σφαλμάτων * / // άλλο κωδικό // ... my_debug ("άλλο μήνυμα εντοπισμού σφαλμάτων", __LINE__); / * θα εξάγει Γραμμή 11: άλλο μήνυμα σφάλματος * / λειτουργία my_debug ($ msg, $ line) (echo "Line $ line: $ msg \\ n";)
6. Δημιουργία μοναδικών αναγνωριστικών
Υπάρχουν φορές που πρέπει να δημιουργήσετε μια μοναδική συμβολοσειρά. Πολλές φορές έχω δει ότι η λειτουργία md5 () χρησιμοποιείται για την επίλυση αυτού του προβλήματος:
// δημιουργεί μια τυχαία συμβολοσειρά echo md5 (time (). mt_rand (1.1000000));
Αλλά στην πραγματικότητα, για το σκοπό αυτό στην PHP υπάρχει μια ειδική λειτουργία uniqid ()
// δημιουργεί μια τυχαία συμβολοσειρά echo uniqid (); / * θα εκτυπώσει 4bd67c947233e * / // άλλη μια φορά echo uniqid (); / * θα εξάγει 4bd67c9472340 * /
Με το γυμνό μάτι, μπορείτε να δείτε ότι οι πρώτοι χαρακτήρες πρέπει να είναι ελαφρώς παρόμοιοι ... Αυτό οφείλεται στο γεγονός ότι αυτή η μέθοδος χρησιμοποιεί χρόνο διακομιστή για να δημιουργήσει χαρακτήρες. Είναι ακόμη χρήσιμο, επειδή όλες οι παραγόμενες τιμές λαμβάνονται με αλφαβητική σειρά, γεγονός που καθιστά δυνατή την ταχεία ταξινόμησή τους.
Για να μειώσουμε τις πιθανότητες λήψης ενός διπλότυπου, μπορούμε να προσθέσουμε ένα πρόθεμα ή να χρησιμοποιήσουμε τη δεύτερη παράμετρο (αύξηση του αριθμού των χαρακτήρων):
// με το πρόθεμα echo uniqid ("foo_"); / * θα εξάγει foo_4bd67d6cd8b8f * / // με τη δεύτερη παράμετρο echo uniqid ("", true); / * θα εξάγει 4bd67d6cd8b926.12135106 * / // και οι δύο echo uniqid ("bar _", true); / * θα εκτυπώσει bar_4bd67da367b650.43684647 * /
Αυτή η μέθοδος δημιουργεί γραμμές μικρότερες από md5, εξοικονομώντας έτσι χώρο.
7. Σειρά
Θα έπρεπε ποτέ να αποθηκεύσετε πολύπλοκα δεδομένα σε μια βάση δεδομένων ή σε ένα αρχείο; Για να μετατρέψετε ένα αντικείμενο σε μια συμβολοσειρά στην PHP, παρέχεται μια ειδική λειτουργία.
Σε γενικές γραμμές, αυτές οι μέθοδοι είναι 2: serialize () και unserialize ()
// πολύπλοκη συστοιχία $ myvar = array ("γεια", 42, συστοιχία (1, "δύο"), "μήλο"); // μετατρέψτε σε συμβολοσειρά $ string = serialize ($ myvar); echo $ string; / * Εμφανίζει ένα: 4: (i: 0? S: 5: "γεια"? I: 1? I: 42? Ί: 2? Α: 2: (i: 0? I: 1? I: 1? S : 3: "δύο";) i: 3; s: 5: "apple";) * / // λαμβάνουμε την αρχική τιμή $ newvar = unserialize ($ string); print_r ($ newvar); / * εμφανίζει Array (=\u003e hello =\u003e 42 =\u003e Array (=\u003e 1 =\u003e δύο) =\u003e μήλο) * /
Έτσι λειτουργούν αυτές οι λειτουργίες. Ωστόσο, λόγω της δημοφιλούς δημοτικότητας του JSON, 2 PHP μέθοδοι json_encode () και json_decode () προστέθηκαν στην PHP 5.2. Το έργο τους είναι παρόμοιο με το serialize ():
// πολύπλοκη συστοιχία $ myvar = array ("γεια", 42, συστοιχία (1, "δύο"), "μήλο"); // μετατρέψτε σε συμβολοσειρά $ string = json_encode ($ myvar); echo $ string; / * θα εξάγει ["hello", 42 ,, "apple"] * / // επαναφορά της αρχικής τιμής $ newvar = json_decode ($ string); print_r ($ newvar); / * εκτυπώνει Array (=\u003e hello =\u003e 42 =\u003e Array (=\u003e 1 =\u003e δύο) =\u003e μήλο) * /
Αυτή η επιλογή είναι πιο συμπαγής και συμβατή με άλλες γλώσσες, όπως η JavaScript. Ωστόσο, όταν εργάζεστε με πολύ συσσωρευμένα αντικείμενα, μπορεί να προκύψει απώλεια δεδομένων.
8. Συμπίεση σειρών
Όταν μιλάμε για συμπίεση, τότε αρχεία αρχείων ZIP έρχονται αμέσως στο μυαλό. Η PHP παρέχει τη δυνατότητα συμπίεσης μεγάλων γραμμών χωρίς αρχεία.
Στο ακόλουθο παράδειγμα, επιδεικνύουμε τη λειτουργία των λειτουργιών gzcompress () και gzuncompress ():
$ String = «Lorem ipsum dolor καθίσει Αμέτ, consectetur adipiscing ελίτ. Nunc ut ελίτ id mi ultricies adipiscing. Nulla facilisi. Μας ελάτε σε επαφή pulvinar, sapien vel feugiat vestibulum, nulla DUI pretium ORCi, μη ultricies ελίτ Lacus QUIS των προτέρων. Lorem ipsum θλίψη καθίσει Αμέτ , consectetur adipiscing ελίτ. aliquam pretium ullamcorper urna QUIS iaculis. Etiam αγ massa sed turpis tempor luctus. Curabitur sed NIBH ΕΕ ελίτ mollis congue. Μας ελάτε σε επαφή ipsum διαμ, σημείωμα consectetur ornare ένα, aliquam ένα nunc. Σε id magna pellentesque TELLUS Έρευνα adipiscing. Sed μη mi metus, σε lacinia augue. sed magna Νησί, ornare στην mollis στο, mollis sed nunc. Etiam σε justo στο leo congue mollis. εκπαιδευτικοί στην neque EGET metus hendrerit scelerisque εε μη enim. Ut malesuada Lacus ΕΕ nulla Bibendum id euismod urna sodales . " $ συμπιεσμένο = gzcompress (συμβολοσειρά $); echo "Αρχικό μέγεθος:". strlen ($ string). \\ n "; / * θα εμφανίσει το πρωτότυπο μέγεθος: 800 * / echo "συμπιεσμένο μέγεθος:". strlen ($ συμπιεσμένο). \\ n "; / * εκτύπωση συμπιεσμένο μέγεθος: 418 * / // επιστροφή $ original = gzuncompress ($ συμπιεσμένο);
Μπορούμε να μειώσουμε το ποσό του κειμένου κατά 50%. Για τον ίδιο σκοπό, μπορείτε να χρησιμοποιήσετε τις μεθόδους gzencode () και gzdecode (), οι οποίες χρησιμοποιούν διαφορετικό αλγόριθμο συμπίεσης.
9. Εκτέλεση πριν από την ολοκλήρωση
Στην PHP, υπάρχει μια λειτουργία register_shutdown_function () που σας επιτρέπει να εκτελέσετε κάποιο κώδικα πριν από την έξοδο από τη δέσμη ενεργειών.
Ας υποθέσουμε ότι θέλετε να μάθετε κάποιες πληροφορίες ... Script runtime:
// πάρτε την ώρα έναρξης $ start_time = microtime (true); // μερικές λειτουργίες // ... // εμφάνιση της ηχούς εκτέλεσης του χρόνου εκτέλεσης: εκτέλεση: ". (microtime (true) - $ start_time). "δευτερόλεπτα".
Με την πρώτη ματιά, αυτό μπορεί να φαίνεται σαν ένα τετριμμένο καθήκον. Για τους σκοπούς αυτούς, μπορείτε να βάλετε τον κώδικα στο τέλος του αρχείου. Ωστόσο, εάν προηγουμένως η λειτουργία εξόδου () λειτουργεί κάπου, αυτός ο κώδικας δε θα λειτουργήσει ποτέ. Επίσης, δεν θα λειτουργήσει εάν υπάρχει σφάλμα στη σελίδα ή ο χρήστης διακόπτει τη φόρτωση της σελίδας (κάνοντας κλικ στο αντίστοιχο κουμπί στο πρόγραμμα περιήγησης).
Όταν χρησιμοποιείτε τη μέθοδο register_shutdown_function (), ο κώδικας θα εκτελεστεί ούτως ή άλλως:
$ start_time = microtime (true); register_shutdown_function ("my_shutdown"); Η λειτουργία my_shutdown () (σφαιρική εκτέλεση $ start_time; echo "πήρε:" (microtime (true) - $ start_time).
Συμπέρασμα
Η PHP είναι ένας ολόκληρος πλανήτης που ποτέ δεν παύει να μας εκπλήσσει με το περιεχόμενό του. Τι νομίζετε για αυτά τα χαρακτηριστικά;
