Γιατί η εργασία .net/c# είναι πιο αργή από το Thread;

Μικρά αποβράσματα · Δημοσιεύτηκε στις 3/5/2017 4:40:28 μ.μ.

Το .NET 4 περιλαμβάνει έναν νέο χώρο ονομάτων, το System.Threading.Tasks, ο οποίος περιέχει που αφαιρούν τη λειτουργικότητα νημάτων. Χρησιμοποιήστε το ThreadPool στο παρασκήνιο. Μια εργασία αντιπροσωπεύει την εργασία μιας μονάδας που πρέπει να ολοκληρωθεί. Η εργασία αυτής της μονάδας μπορεί να εκτελεστεί σε ξεχωριστό νήμα ή μια εργασία μπορεί να ξεκινήσει συγχρονισμένα, κάτι που απαιτεί αναμονή για το κύριο νήμα συντονισμού. Η χρήση εργασιών όχι μόνο σας δίνει ένα επίπεδο αφαίρεσης, αλλά σας δίνει επίσης μεγάλο έλεγχο στα υποκείμενα νήματα.
Οι εργασίες προσφέρουν μεγάλη ευελιξία όσον αφορά τον προγραμματισμό της εργασίας που πρέπει να γίνει. Για παράδειγμα, μπορείτε να ορίσετε μια συνεχή εργασία – ποια εργασία πρέπει να γίνει μετά την ολοκλήρωση μιας εργασίας. Αυτό μπορεί να κάνει τη διαφορά μεταξύ μιας επιτυχημένης εργασίας και όχι. Επιπλέον, οι εργασίες μπορούν να ταξινομηθούν σε μια ιεραρχία. Για παράδειγμα, μια γονική εργασία μπορεί να δημιουργήσει μια νέα θυγατρική εργασία. Αυτό δημιουργεί μια εξάρτηση, έτσι ώστε εάν ακυρώσετε τη γονική εργασία, η θυγατρική εργασία θα ακυρωθεί επίσης.

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

Δοκίμασα μόνος μου το Task and Thread και πιστεύω ότι το Task είναι πολύ αργό, γεγονός που επηρεάζει πολύ την απόδοση και ο κωδικός δοκιμής είναι ο εξής:

Η σύνδεση είναι ορατή.

Κάνουμε βρόχο στη μέθοδο 1000 φορές και, στη συνέχεια, η μέθοδος μπλοκάρει για 100 χιλιοστά του δευτερολέπτου και το αποτέλεσμα της δοκιμής είναι το εξής:

Έκβαση:
Η εκτέλεση του νήματος διαρκεί 188 χιλιοστά του δευτερολέπτου
Η εκτέλεση της εργασίας διαρκεί 14.671 χιλιοστά του δευτερολέπτου

Η διαφορά ταχύτητας μεταξύ των δύο είναι 78 φορές!!

Η εργασία είναι πολύ αργή, δεν ξέρω γιατί συμβαίνει αυτό, υπάρχει κάποιο πρόβλημα με τον κωδικό δοκιμής μου ή τι; Ελπίζω να μπορείτε να εξηγήσετε γιατί συμβαίνει αυτό...

Μικρά αποβράσματα

tongli1996218 Δημοσιεύτηκε στις 2020-10-13 09:34
Για να διασφαλίσω τον ίδιο κώδικα με το Thread, η λειτουργία μου είναι ο ακόλουθος κώδικας και ο παραπάνω είναι ψευδοκώδικας
ΥΓ: Απλώς καλέστε το wait Task.Delay χωρίς να προσθέσετε ...

Ναι ευχαριστώ

Χρόνος εκτέλεσης εργασίας: 117.0357

Η σύνδεση είναι ορατή.

Μπορείτε να τροποποιήσετε τον κώδικα ως εξής:

Η σύνδεση είναι ορατή.

Το Task.Run αντικαθιστά το Task.Factory.StartNew επειδή αποσυσκευάζει αυτόματα τις εσωτερικές εργασίες.
Το Task.WaitAll περιμένει μια εξωτερική εργασία αντί για μια εσωτερική. Η χρήση του Task.Run δεν έχει ένθετες εργασίες.

Εξετάζοντας την τεκμηρίωση του msdn, μπορείτε να δείτε ότι η μέθοδος Task.Delay Method δημιουργεί μια εργασία που ολοκληρώνεται μετά από έναν καθορισμένο αριθμό χιλιοστών του δευτερολέπτου. (Στην πραγματικότητα, θα δημιουργηθεί ένα νέο νήμα και θα περιμένει να προστεθεί για να περιμένει να εκτελεστεί η εργασία, δεν ξέρω αν καταλαβαίνω καλά)

Η σύνδεση με υπερσύνδεσμο είναι ορατή.

Επιπλέον, υπάρχει διαφορά μεταξύ Task και void

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

Αναφορά:

Η σύνδεση με υπερσύνδεσμο είναι ορατή.
Η σύνδεση με υπερσύνδεσμο είναι ορατή.

Συνοπτικά: υπάρχει πρόβλημα με τον κώδικα, δεν πρέπει να χρησιμοποιήσω το Thread.Sleep μέσα στη μέθοδο Task

susu996 · Δημοσιεύτηκε στις 21/7/2020 1:09:29 μ.μ.

Είχα το ίδιο πρόβλημα σήμερα, χρησιμοποιώντας multithreading για κρυπτογράφηση AES, το Task είναι πολύ πιο αργό από το Thread!!
Έχει βρει ο ιδιοκτήτης τον λόγο;

tongli1996218 · Δημοσιεύτηκε στις 12/10/2020 7:24:48 μ.μ.

Αυτή η ανάρτηση τροποποιήθηκε τελευταία φορά από τον/την tongli1996218 στις 2020-10-12 19:43

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

Αργότερα διαπιστώθηκε ότι η μέθοδος Thread.Sleep(100) είχε αρνητικό αντίκτυπο στο Task, αλλά όχι στο Thread, και το Thread.Sleep(100) θα μπορούσε να αντικατασταθεί με άλλη χρονοβόρα επαλήθευση του προγράμματος, όπως η αριθμητική αυτοπρόσθεση ή η αναμονή του Task.Delay(100).

ΥΓ: Το Thread.Sleep θα τερματίσει τον τρέχοντα χρόνο τεμαχισμού του νήματος μετά την κλήση, όπως το Thread.Sleep(0) θα τερματίσει τον τρέχοντα χρόνο τεμαχισμού του νήματος και θα τον μεταφέρει σε άλλα νήματα για εκτέλεση. Μέσα στην εργασία υπάρχει μια ομάδα νημάτων, η οποία μπορεί να βελτιστοποιήσει την εναλλαγή περιβάλλοντος των νημάτων και να μειώσει τον χρόνο απώλειας της CPU (ειδικά για βελτιστοποίηση CPU πολλαπλών πυρήνων), ενώ το Thread.Sleep(100) θα διαταράξει τη λογική μεταγωγής της αρχικής ομάδας νημάτων της εργασίας, προκαλώντας μεγάλη απώλεια χρόνου της CPU

Εάν αντικαταστήσετε το Thread.Sleep(100) με το wait Task.Delay(100), θα διαπιστώσετε ότι η κατανάλωση χρόνου της εργασίας είναι μόνο μεγαλύτερη από 100 χιλιοστά του δευτερολέπτου, όπως φαίνεται παρακάτω:
ιδιωτικό κενό TaskTest()
{
      Νήμα.Ύπνος(100);
      ... Εκτέλεση της ενέργειας
}
Αντικαταστάθηκε από
ιδιωτικό ασύγχρονο κενό TaskTest()
{
   Task.Delay(100);
   ... Η εκτέλεση διαρκεί περισσότερα από 100 χιλιοστά του δευτερολέπτου για την εργασία, η οποία είναι ίδια με το αρχικό Thread.Sleep(100) για το Thread
}

Μικρά αποβράσματα

tongli1996218 Δημοσιεύτηκε στις 2020-10-12 19:24
Μετά τη δοκιμή του κωδικού κατόχου, όταν ξεκινήσει το πρόγραμμα, ο χρόνος της εργασίας θα συνεχίσει να μειώνεται μετά από πολλές εκτελέσεις και στον υπολογιστή μου θα μειωθεί σε λιγότερο από το Thread...

Προσπάθησα να το αλλάξω σε κώδικα ως εξής:

Η σύνδεση είναι ορατή.

Task.Delay(100000);

Χρόνος εκτέλεσης εργασίας:14.1306 κ., ο συνολικός χρόνος είναι πράγματι πολύ μικρός, ωστόσο, διαπίστωσα ότι η μέθοδος που κάλεσε το Task δεν ολοκλήρωσε την εκτέλεση.

tongli1996218 · Δημοσιεύτηκε στις 13/10/2020 9:34:33 π.μ.

Αυτή η ανάρτηση επεξεργάστηκε τελευταία φορά από τον/την tongli1996218 στις 2020-10-13 09:40

Δημοσιεύτηκε στις 2020-10-12 22:53
Προσπάθησα να το αλλάξω σε κώδικα ως εξής:
Εργασία.Καθυστέρηση(100000);

Για να διασφαλίσω τον ίδιο κώδικα με το Thread, η λειτουργία μου είναι ο ακόλουθος κώδικας και ο παραπάνω είναι ψευδοκώδικας
ΥΓ: Απλώς καλέστε το wait Task.Delay και, στη συνέχεια, μην προσθέσετε κωδικό, το νήμα που ανοίγει η εργασία επιστρέφεται αμέσως, προκειμένου να διασφαλιστεί η προσομοίωση του υπολογιστικού δεσμευμένου, μπορείτε να χρησιμοποιήσετε για (int a = 0; α< 1000000· ++a){}; Αντίθετα, οι μέθοδοι αυτές

ιδιωτικό ασύγχρονο στατικό κενό TaskTest()
      {
         αναμονή Task.Delay(100000);
         Interlocked.Increment(ref run); κλείδωμα, αλλά η επιβάρυνση είναι μικρότερη
         if(run == j)
         {
            χρονόμετρο. Διακοπή(); Διακοπή παρακολούθησης
            Χρονικό διάστημα TimeSpan = χρονόμετρο. Πέρασε;  Λαμβάνει τον συνολικό χρόνο που μετράται από την τρέχουσα παρουσία
            Console.WriteLine("Χρόνος εκτέλεσης εργασίας:" + χρονικό διάστημα. ΣύνολοΧιλιοστά του δευτερολέπτου); Συνολικά χιλιοστά του δευτερολέπτου
            }
      Ο χρόνος που καταναλώνεται είναι επίσης πολύ μικρός

[Πηγή] Γιατί η εργασία .net/c# είναι πιο αργή από το Thread;

Ενότητες που προβλήθηκαν