Ένας οδηγός για τον ατρόμητο συγχρονισμό του Rust

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

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

Κατανόηση του Concurrency in Rust

Το Rust παρέχει πολλά πρωτόγονα ταυτόχρονης εγγραφής για τη σύνταξη ταυτόχρονων προγραμμάτων, συμπεριλαμβανομένων νημάτων, μετάδοσης μηνυμάτων, mutexes, ατομικών τύπων και async/wait για ασύγχρονο προγραμματισμό.

Ακολουθεί μια επισκόπηση των πρωτόγονων συγχρονισμού του Rust:

1. Νήματα: Η σκουριά παρέχει α std:: νήμα μονάδα στην τυπική βιβλιοθήκη του για τη δημιουργία και τη διαχείριση νημάτων. Μπορείτε να δημιουργήσετε νέα νήματα με το νήμα:: ωοτοκία λειτουργία. ο νήμα:: ωοτοκία παίρνει ένα κλείσιμο που περιέχει τον κώδικα για εκτέλεση. Μπορείτε επίσης να εκτελέσετε νήματα που μπορούν να εκτελούνται παράλληλα και το Rust παρέχει πρωτόγονα συγχρονισμού για τον συντονισμό της εκτέλεσής τους. Το δάνειο πούλι διασφαλίζει ότι οι αναφορές δεν οδηγούν σε απροσδόκητες συμπεριφορές.
2. Πέρασμα μηνύματος: Το μοντέλο συγχρονισμού του Rust υποστηρίζει τη μετάδοση μηνυμάτων μεταξύ των νημάτων. Θα χρησιμοποιήσετε τα κανάλια που υλοποιούνται μέσω του std:: sync:: mpsc μονάδα για τη μετάδοση μηνυμάτων. Ένα κανάλι αποτελείται από έναν πομπό (Αποστολέας) και έναν δέκτη (Δέκτης). Τα νήματα μπορούν να στέλνουν μηνύματα μέσω του πομπού και να τα λαμβάνουν μέσω του δέκτη. Αυτό παρέχει έναν ασφαλή και συγχρονισμένο τρόπο επικοινωνίας μεταξύ των νημάτων.
3. Mutexes και ατομικοί τύποι: Το Rust παρέχει πρωταρχικά στοιχεία συγχρονισμού, συμπεριλαμβανομένων των mutexes (std:: sync:: Mutex) και ατομικούς τύπους (std:: sync:: ατομικός), για να διασφαλιστεί η αποκλειστική πρόσβαση σε κοινή χρήση δεδομένων. Τα Mutexe επιτρέπουν σε πολλαπλά νήματα να έχουν πρόσβαση σε δεδομένα ταυτόχρονα, ενώ αποτρέπουν τις φυλές δεδομένων. Οι ατομικοί τύποι παρέχουν ατομικές λειτουργίες σε κοινόχρηστα δεδομένα, όπως η αύξηση ενός μετρητή, χωρίς να απαιτείται ρητό κλείδωμα.
4. Async/Await και Futures: Του Rust ασυγχρονισμός/αναμένω σύνταξη παρέχει λειτουργικότητα για τη σύνταξη ασύγχρονου κώδικα που μπορείτε να εκτελέσετε ταυτόχρονα. Τα ασύγχρονα προγράμματα αντιμετωπίζουν αποτελεσματικά εργασίες που συνδέονται με I/O, επιτρέποντας στα προγράμματα να εκτελούν άλλες εργασίες ενώ περιμένουν άλλες λειτουργίες I/O. Του Rust ασυγχρονισμός/αναμένω η σύνταξη βασίζεται σε συμβόλαια μελλοντικής εκπλήρωσης και μπορείτε να τα τροφοδοτήσετε με το async-std ή Τόκιο βιβλιοθήκες χρόνου εκτέλεσης.

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

Πώς να χρησιμοποιήσετε τα νήματα ωοτοκίας στη σκουριά

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

Δείτε πώς μπορείτε να δημιουργήσετε ένα νήμα με το std:: νήμα:: αναπαραγωγή λειτουργία:

χρήση std:: νήμα;
στκύριος() {
// Δημιουργία νέου νήματος
αφήνω thread_handle = νήμα:: spawn(|| {
// Ο κώδικας που εκτελείται στο νέο νήμα πηγαίνει εδώ
println!("Γεια από το νέο νήμα!");
 });
// Περιμένετε να τελειώσει το νήμα που γεννήθηκε
 thread_handle.join().unwrap();
// Ο κώδικας που εκτελείται στο κύριο νήμα συνεχίζεται εδώ
println!("Γεια από το κεντρικό νήμα!");
}

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

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

Μπορείτε να δημιουργήσετε πολλά νήματα και να χρησιμοποιήσετε έναν βρόχο ή οποιοδήποτε άλλο Δομή ελέγχου σκουριάς για να δημιουργήσετε πολλαπλά κλεισίματα και νήματα αναπαραγωγής για το καθένα.

χρήση std:: νήμα;
στκύριος() {
αφήνω num_threads = 5;
αφήνωmut νήμα_λαβές = vec![];
Για Εγώ σε0..num_threads {
αφήνω thread_handle = thread:: spawn(κίνηση || {
println!("Γεια από το νήμα {}", Εγώ);
 });
 thread_handles.push (thread_handle);
 }
Για λαβή σε νήμα_λαβές {
 handle.join().unwrap();
 }
println!("Όλα τα νήματα τελείωσαν!");
}

Ο βρόχος for δημιουργεί πέντε νήματα, το καθένα εκχωρημένο σε ένα μοναδικό αναγνωριστικό Εγώ με τη μεταβλητή βρόχου. Τα κλεισίματα αποτυπώνουν την αξία του Εγώ με την κίνηση λέξη-κλειδί προς αποφυγή ζητήματα ιδιοκτησίας, και το νήμα_λαβές Το διάνυσμα αποθηκεύει τα νήματα για αργότερα στο Συμμετοχή βρόχος.

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

Διαβίβαση μηνυμάτων μέσω καναλιών

Μπορείτε να περάσετε μηνύματα μέσω νημάτων με κανάλια. Το Rust παρέχει λειτουργικότητα για τη μετάδοση μηνυμάτων στο std:: sync:: mpsc μονάδα μέτρησης. Εδώ, mpsc σημαίνει "πολλαπλός παραγωγός, μεμονωμένος καταναλωτής" και επιτρέπει την επικοινωνία μεταξύ πολλαπλών νημάτων με αποστολή και λήψη μηνυμάτων μέσω καναλιών.

Δείτε πώς εφαρμόζετε το μήνυμα που περνά μέσα από κανάλια επικοινωνίας μεταξύ νημάτων στα προγράμματά σας:

χρήση std:: sync:: mpsc;
χρήση std:: νήμα;
στκύριος() {
// Δημιουργία καναλιού
αφήνω (αποστολέας, δέκτης) = mpsc:: κανάλι();
// Δημιουργήστε ένα νήμα
 thread:: spawn(κίνηση || {
// Στείλτε ένα μήνυμα μέσω του καναλιού
 sender.send("Γεια από το νήμα!").ξεδιπλώνω();
 });
// Λήψη του μηνύματος στο κύριο νήμα
αφήνω receive_message = receiver.recv().unwrap();
println!("Ληφθέν μήνυμα: {}", receive_message);
}

ο κύριος η λειτουργία δημιουργεί ένα κανάλι με mpsc:: κανάλι() που επιστρέφει α αποστολέας και ένα δέκτης. ο αποστολέας στέλνει μηνύματα στο δέκτης που λαμβάνει τα μηνύματα. ο κύριος η λειτουργία προχωρά στη δημιουργία νημάτων και τη μετακίνηση της ιδιοκτησίας του Αποστολέας μέχρι το κλείσιμο του νήματος. Μέσα στο κλείσιμο κλωστής, το sender.send() η λειτουργία στέλνει μήνυμα μέσω του καναλιού.

ο receiver.recv() Η συνάρτηση λαμβάνει το μήνυμα σταματώντας την εκτέλεση έως ότου το νήμα λάβει το μήνυμα. ο κύριος Η λειτουργία εκτυπώνει το μήνυμα στην κονσόλα μετά από επιτυχή λήψη του μηνύματος.

Σημειώστε ότι η αποστολή μηνύματος μέσω του καναλιού καταναλώνει τον αποστολέα. Εάν χρειάζεται να στείλετε μηνύματα από πολλά νήματα, μπορείτε να κλωνοποιήσετε τον αποστολέα με το sender.clone() λειτουργία.

Επιπλέον, το mpsc Η ενότητα παρέχει άλλες μεθόδους όπως try_recv(), το οποίο χωρίς αποκλεισμό προσπαθεί να λάβει ένα μήνυμα και iter (), το οποίο δημιουργεί έναν επαναλήπτη πάνω από τα ληφθέντα μηνύματα.

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

Το Rust's Ownership and Borrowing Model εγγυάται την ασφάλεια της μνήμης

Το Rust συνδυάζει την ιδιοκτησία, τον δανεισμό και τον έλεγχο δανεισμού για να παρέχει ένα ισχυρό, ασφαλές, ταυτόχρονο πλαίσιο προγραμματισμού.

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