Νήμα (υπολογιστές)

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

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

Σε έναν απλό επεξεργαστή, η πολυνημάτωση (multithreading) πραγματοποιείται με τη μέθοδο της πολυπλεξίας με διαίρεση χρόνου (όπως στην πολυεπεξεργασία): ο επεξεργαστής μεταπηδάει μεταξύ των διάφορων νημάτων. Αυτή η εναλλαγή μεταξύ των διεργασιών ονομάζεται Μεταγωγή περιβάλλοντος (Αγγλικά: context switch) [1], και συμβαίνει σε πολύ τακτά χρονικά διαστήματα, τέτοια έτσι ώστε ο χρήστης έχει την εντύπωση ότι τα νήματα εκτελούνται την ίδια στιγμή. Μόνο σε έναν επεξεργαστή με πολλούς επεξεργαστικούς πυρήνες, τα νήματα εκτελούνται πραγματικά ταυτόχρονα και κάθε πυρήνας εκτελεί ένα συγκεκριμένο νήμα ή εργασία. [2] [3]

Η υποστήριξη για νήματα ποικίλει ανάμεσα στις γλώσσες προγραμματισμού: κάποιες γλώσσες απλά δεν υποστηρίζουν την εκτέλεση παραπάνω του ενός νήματος για ένα πρόγραμμα ταυτόχρονα. Παραδείγματα τέτοιων γλωσσών είναι η Python και η OCaml οι οποίες παρόλο που έχουν βιβλιοθήκες για δημιουργία νημάτων δεν εκτελούνται τα νήματα ταυτόχρονα [4] [5]. Άλλες γλώσσες περιορίζονται στη χρήση νημάτων χρήστη τα οποία δεν είναι ορατά στο πυρήνα και έτσι δεν μπορούν να εκτελεστούν ταυτόχρονα. Μόνο τα νήματα πυρήνα που είναι ορατά στον χρονοδρομολογητή του πυρήνα, μπορούν να εκτελεστούν ταυτόχρονα.

Πολλά σύγχρονα λειτουργικά συστήματα υποστηρίζουν τόσο νήματα καταμερισμού χρόνου, όσο και νήματα παράλληλης πολυεπεξεργασίας, στον χρονοδρομολογητή τους. Ο πυρήνας ενός λειτουργικού συστήματος επιτρέπει στους προγραμματιστές να χειρίζονται τα νήματα μέσω της διεπαφής κλήσεων συστήματος. [6] Ορισμένες υλοποιήσεις λέγονται νήμα πυρήνα, ενώ ελαφρά διεργασία είναι ο ειδικός τύπος νήματος πυρήνα που μοιράζεται την ίδια κατάσταση και πληροφορίες. [7]Στα συστήματα unix υπάρχει το POSIX στάνταρντ για δημιουργία POSIX νημάτων.

Πως διαφέρει ένα νήμα από μια διεργασία[Επεξεργασία | επεξεργασία κώδικα]

Ένα νήμα διαφέρει από μια διεργασία ενός πολυεπεξεργαστικού λειτουργικού συστήματος στα εξής:

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

Ένα πρόγραμμα που μεταγλωττίζεται δημιουργείται ένα εκτελέσιμο αρχείο. Αυτό όταν εκτελείται δημιουργείται μια νέα διεργασία μέσα στην οποία τρέχει ο εκτελέσιμος κώδικας. Το λειτουργικό σύστημα φροντίζει να δημιουργήσει χώρο μνήμης-διευθύνσεων για την διεργασία. Στο unix κάθε εκτέλεση του εκτελέσιμου αρχείου δημιουργεί μια νέα ξεχωριστή διεργασία η οποία τρέχει παράλληλα (ή ψευδοπαράλληλα με την τεχνική διαίρεσης χρόνου - όταν έχουμε ένα επεξεργαστή). Το νήμα είναι μια πολύ πιο "ελαφριά" μορφή διεργασίας όπου η δημιουργία είναι εκατοντάδες φορές πιο γρήγορη από την δημιουργία μιας διεργασίας. Τα νήματα τρέχουν παράλληλα όπως και οι διεργασίες. Η ιδέα είναι ότι δημιουργούμε μια διεργασία και μέσα από αυτή δημιουργούμε νήματα τα οποία έχουν πρόσβαση στο χώρο μνήμης της διεργασίας. [8] [9] Ας δούμε ένα παράδειγμα POSIX νήματος το οποίο μεταγλωττίζεται στο unix με την gcc thread.c -o thread -lpthread:

/* thread.c */
#include <pthread.h>
#include <stdlib.h>
#include <unistd.h> 
#include <stdio.h>
 
void *thread_function(void *arg) {
  int i;
  for ( i=0; i<20; i++ ) {
    printf("Το νήμα λέει γεια!\n");
    sleep(1);
  }
  return NULL;
}
 
int main(void) {
 
  pthread_t mythread;
 
  if ( pthread_create( &mythread, NULL, thread_function, NULL) ) {
    printf("σφάλμα κατά την δημιουργία του νήματος.");
    abort();
  }
 
  if ( pthread_join ( mythread, NULL ) ) {
    printf("σφάλμα κατά την pthread_join.");
    abort();
  }
 
  exit(0);
 
}

Στο συγκεκριμένο παράδειγμα έχουμε ένα πρόγραμμα το οποίο μόλις εκτελεστεί το λειτουργικό σύστημα δημιουργεί την διεργασία μέσα στην οποία τρέχει. Στην συνέχεια το πρόγραμμα δημιουργεί ένα νήμα μέσω της συνάρτησης pthread_create( &mythread, NULL, thread_function, NULL) το οποίο εμφανίζει το μήνυμα Το νήμα λέει γεια! 20 φορές με καθυστέρηση 1 δευτερόλεπτο κάθε φορά στην οθόνη. Παρόλο που μέσα στο πρόγραμμα δημιουργήσαμε μόνο ένα νήμα, στην πράξη τρέχουν δύο νήματα. Η συνάρτηση main() τρέχει μέσα στην διεργασία ως νήμα και στην συνέχεια δημιουργείται το δεύτερο νήμα μέσω της pthread_create. Η pthread_create "σπάει" το κύριο νήμα main σε δύο νήματα που τρέχουν παράλληλα. Η συνάρτηση pthread_join παίρνει ως παράμετρο tο νήμα που δημιουργήσαμε μόλις ολοκληρώσει το "ενώνει" με το κύριο νήμα main. Η συνάρτηση pthread_join λειτουργεί και ως εκκαθαριστής των νημάτων. Αν συνεχώς δημιουργούμε νήματα χωρίς να τρέχουμε την pthread_join το σύστημα θα φτάσει στον μέγιστο αριθμό επιτρεπόμενων νημάτων και η pthread_create δεν θα μπορεί να δημιουργεί νέα νήματα. [10]

Πολυνημάτωση[Επεξεργασία | επεξεργασία κώδικα]

Η πολυνημάτωση (Αγγλικά: multithreading) αποτελεί ένα ευρέως διαδεδομένο μοντέλο προγραμματισμού και εκτέλεσης διεργασιών το οποίο επιτρέπει την ύπαρξη πολλών νημάτων μέσα στα πλαίσια μιας και μόνο διεργασίας. Τα νήματα αυτά μοιράζονται τους πόρους της διεργασίας και μπορούν να εκτελούνται ανεξάρτητα. Η πολυνημάτωση δεν πρέπει να μπερδεύεται με την πολυδιεργασία (Αγγλικά: multitasking) όπου έχει να κάνει με την εκτέλεση προγραμμάτων δηλαδή διεργασιών παράλληλα σε ένα υπολογιστικό σύστημα με πολλούς επεξεργαστές. Το πλεονέκτημα ενός πολυνηματικού προγράμματος είναι ότι του επιτρέπει να εκτελείται γρηγορότερα σε υπολογιστικά συστήματα που έχουν πολλούς επεξεργαστές, επεξεργαστές με πολλούς πυρήνες, ή κατά μήκος μιας συστοιχίας υπολογιστών. Για να μπορούν να χειραγωγηθούν σωστά τα δεδομένα, τα νήματα θα πρέπει ορισμένες φορές να συγκεντρωθούν σε ένα ορισμένο χρονικό διάστημα έτσι ώστε να επεξεργασθούν τα δεδομένα στη σωστή σειρά. Ένα ακόμα πλεονέκτημα της πολυδιεργασίας (και κατ επέκταση της πολυνημάτωσης) ακόμα και στους απλούς επεξεργαστές ( με έναν πυρήνα επεξεργασίας) είναι η δυνατότητα για μια εφαρμογή να ανταποκρίνεται άμεσα. Έχοντας ένα πρόγραμμα που εκτελείται μόνο σε ένα νήμα, αυτό θα φαίνεται ότι κολλάει ή ότι παγώνει, στις περιπτώσεις που εκτελείται κάποια μεγάλη διεργασία που απαιτεί πολύ χρόνο. Αντίθετα σε ένα πολυνηματικό σύστημα, οι χρονοβόρες διεργασίες μπορούν να εκτελούνται παράλληλα με άλλα νήματα που φέρουν άλλες εντολές για το ίδιο πρόγραμμα, καθιστώντας το άμεσα ανταποκρίσιμο. [11]

Τα λειτουργικά συστήματα προγραμματίζουν τα νήματα με έναν από τους δύο παρακάτω τρόπους:

  1. Πολυδιεργασία προτίμησης (Αγγλικά: Preemptive multitasking): γενικώς θεωρείται η καλύτερη προσέγγιση. Σύμφωνα με αυτή, το λειτουργικό σύστημα καθορίζει πότε θα γίνεται μια εναλλαγή από το ένα νήμα στο άλλο. Μειονέκτημα αυτής της μεθόδου είναι ότι το σύστημα μπορεί να πραγματοποιήσει μια εναλλαγή σε ακατάλληλη στιγμή με αρνητικές επιπτώσεις για τις εφαρμογές που εκτελούνται. [12]
  2. Πολυνημάτωση συνεργασίας (Αγγλικά: Cooperative multithreading): Σύμφωνα με αυτή τη προσέγγιση, τα ίδια τα νήματα αναλαμβάνουν τον έλεγχο. Έτσι όταν ένα νήμα τελειώσει, παραδίδει τους πόρους εκτέλεσης σε άλλο νήμα. Μειονέκτημα αυτής της προσέγγισης είναι ότι ένα νήμα μπορεί να περιμένει επ’ αόριστον να ελευθερωθούν πόροι συστήματος. [13]

Μέχρι και τα τέλη της δεκαετίας του 1990, οι πιο δημοφιλείς επεξεργαστές των προσωπικών υπολογιστών δεν υποστήριζαν πολλαπλά νήματα εκτέλεσης - κάποια λειτουργικά συστήματα υποστήριζαν τη χρήση νημάτων στο λογισμικό, που δεν εκτελούνταν πραγματικά παράλληλα αλλά από τον χρονοπρογραμματιστή του συστήματος, και είχαν εφαρμογές κυρίως στην επεξεργασία δεδομένων. Ωστόσο, επεξεργαστές σε άλλα ενσωματωμένα συστήματα που είχαν υψηλές απαιτήσεις για ανταπόκριση σε πραγματικό χρόνο (όπως π.χ. φανάρια σηματοδότησης, ελεγκτές εργοστασιακών μηχανών κ.α.) υποστήριζαν μια μορφή πολυνημάτωσης. Με το πέρας της δεκαετίας του 1990, η ιδέα της ταυτόχρονης εκτέλεσης εντολών σε πολλαπλά νήματα, γνωστή ως ταυτόχρονη πολυνημάτωση, υλοποιήθηκε και στους προσωπικούς υπολογιστές με το λανσάρισμα των επεξεργαστών Pentium 4 της Intel, με την ονομασία Υπερνημάτωση. Η απόγονη αρχιτεκτονική πού ακολούθησε τους Pentium 4 (εμπορικά προϊόντα Core και Core 2) δεν την ενσωμάτωνε. Από το 2008 και με την έλευση της αρχιτεκτονικής Nehalem και μέχρι σήμερα, η υπερνημάτωση επανεμφανίστηκε με βελτιώσεις στις σειρές επεξεργαστών Intel Core i5 και Core i7.

Διεργασίες, νήματα πυρήνα και νήματα χρήστη[Επεξεργασία | επεξεργασία κώδικα]

Ένα νήμα χρήστη (Αγγλικά: user thread) είναι συνδεδεμένο με το εκτελέσιμο κώδικα που τρέχει στην διεργασία και δημιουργείται από το χρήστη χρησιμοποιώντας μια βιβλιοθήκη δημιουργίας νημάτων (όπως τα POSIX νήματα που δημιουργούνται από την βιβλιοθήκη pthread). Η εναλλαγή των νημάτων μιας διεργασίας γίνεται από την ίδια την διεργασία ενώ ο πυρήνας του λειτουργικού συστήματος αναλαμβάνει μόνο την εναλλαγή των διεργασιών. Κατά την εναλλαγή των νημάτων μέσα στην διεργασία αναλαμβάνει η διεργασία και δεν γίνονται κλήσεις συστήματος πυρήνα. Ένα μειονέκτημα των νημάτων χρήστη είναι ότι όταν ένα νήμα κολλήσει τότε ο πυρήνας του λειτουργικού συστήματος βλέπει μόνο την διεργασία που τρέχει όχι το προβληματικό νήμα. Ένα νήμα πυρήνα (Αγγλικά: kernel thread) αποτελεί την ελαφρύτερη μονάδα που μπορεί να δρομολογηθεί υλοποιείται και τρέχει μέσα στον πυρήνα του λειτουργικού συστήματος. Η δημιουργία-εκκίνηση αλλά και ο τερματισμός ενός νήματος πυρήνα γίνεται με κατευθείαν κλείσεις συστήματος μέσα στον πυρήνα. [14] Ανάλογα με το λειτουργικό σύστημα διαφέρει το μοντέλο που ακολουθείται στην υλοποίηση νημάτων. Παρακάτω βλέπουμε τα μοντέλα [15]:

  • Πολλά σε Ένα: πολλά νήματα χρήστη αντιστοιχίζονται σε ένα νήμα πυρήνα - τα πράσινα νήματα. [16]
  • Ένα προς Ένα: ένα νήμα χρήστη αντιστοιχίζεται σε ένα νήμα πυρήνα. [17]
  • Πολλά προς Πολλά: πολλά νήματα χρήστη να αντιστοιχιστούν σε πολλά νήματα πυρήνα. [18]

Ta Πράσινα νήματα είναι νήματα χρήστη που υλοποιούνται σε επίπεδο εφαρμογής και δεν χρησιμοποιούνται κλήσεις συστήματος μέσα στο πυρήνα σε αντίθεση με τα χαμηλού επιπέδου νήματα naive threads τα οποία χρησιμοποιούν κλήσεις συναρτήσεων πυρήνα. [19]

Δείτε επίσης[Επεξεργασία | επεξεργασία κώδικα]

Εξωτερικοί σύνδεσμοι[Επεξεργασία | επεξεργασία κώδικα]

Παραπομπές[Επεξεργασία | επεξεργασία κώδικα]

  1. Γ.Παπακωνσταντίνου, Π.Τσανάκας, Ν.Κοζύρης, Α.Μανουσοπούλου, Π.Ματζάκος (1999). Τεχνολογία Υπολογιστικών Συστημάτων και Λειτουργικά Συστήματα Γ' Ενιαίου Λυκείου Βιβλίο Μαθητή. ΟΕΔΒ. σελ. 186. ISBN 9789607251251. http://ebooks.edu.gr/modules/ebook/show.php/DSB103/173/1211,4429/. 
  2. Tayal, Bharat Bhushan Agarwal, Sumit Prakash (2009). Computer architecture and parallel processing (1st ed. έκδοση). New Delhi: University Science Press. σελ. 17-18. ISBN 978-8131804988. http://books.google.gr/books?id=1cnhfgqf2E4C&pg=PA17#v=onepage&q&f=false. 
  3. Haldar, Sibsankar; Aravind, Alex A. (2010). Operating systems. Upper Saddle River, NJ: Pearson. σελ. 118. ISBN 9788131730225. http://books.google.gr/books?id=orZ0CLxEMXEC&pg=PA118#v=onepage&q&f=false. 
  4. Martelli, Alex (2006). Python in a nutshell (2nd ed. έκδοση). Beijing: O'Reilly. σελ. 341. ISBN 978-0-596-10046-9. http://books.google.gr/books?id=JnR9hQA3SncC&pg=PA341#v=onepage&q&f=false. 
  5. Marsh, Charlie. «True Parallelism in OCaml». Personal home page at princeton.edu. http://www.princeton.edu/~crmarsh/ocaml_parallelism/. 
  6. «Χρονοδρομολόγηση ΚΜΕ». Εργαστήριο Υπολογιστικών Συστημάτων - Εθνικό Μετσόβιο Πολυτεχνείο. http://www.cslab.ntua.gr/courses/os/files/2013-14/os-04-scheduling.pdf. 
  7. Naghibzadeh, M. (2005). Operating system concepts and techniques. New York: iUniverse. σελ. 80-81. ISBN 978-0-5953-7597-4. http://books.google.gr/books?id=QB30VItk1ksC&pg=PA80#v=onepage&q&f=false. 
  8. Mitchell, Mark; Oldham,, Jeffrey; Samuel, Alex (2001). Advanced Linux programming (1st ed. έκδοση). Indianapolis, Ind.: New Riders Pub.. σελ. 61-62. ISBN 978-0735710436. http://www.advancedlinuxprogramming.com/alp-folder/alp-ch04-threads.pdf. 
  9. Butenhof, David R. (1997). Programming with POSIX threads ([Nachdr.] έκδοση). Reading, Mass.: Addison Wesley Professional. σελ. 1-2. ISBN 0-201-63392-2. 
  10. Robbins, Daniel. «POSIX threads explained: A simple and nimble tool for memory sharing». 01 Ιουλίου 2000. IBM developer works. http://www.ibm.com/developerworks/library/l-posix1/index.html. Ανακτήθηκε στις 27 Μαΐου 2014. 
  11. «Differences Between Multithreading and Multitasking for Programmers». 20 Ιανουαρίου 2014. National Instruments. http://www.ni.com/white-paper/6424/en/. Ανακτήθηκε στις 28 Μαΐου 2014. 
  12. Lowe, Doug (2008). Networking all-in-one desk reference for dummies (3rd ed. έκδοση). Hoboken, N.J.: Wiley. σελ. 63. ISBN 978-0-470-17915-4. http://books.google.gr/books?id=XeKLe6B70-0C&pg=PA63#v=onepage&q&f=false. 
  13. Tayal, Bharat Bhushan Agarwal, Sumit Prakash (2009). Computer architecture and parallel processing (1st ed. έκδοση). New Delhi: University Science Press. σελ. 13-14. ISBN 978-8131804988. http://books.google.gr/books?id=1cnhfgqf2E4C&pg=PA13#v=onepage&q&f=false. 
  14. Dhamdhere, Dhananjay M. (2006). Operating systems : a concept-based approach (2nd ed. έκδοση). Boston: McGraw-Hill. σελ. 106-114. ISBN 0070611947. http://books.google.gr/books?id=kbBn4X9x2mcC&pg=PA106#v=onepage&q&f=false. 
  15. I. A. Dhotre (2009). Operating Systems. Pune - India: Technical Publications Pune. σελ. 3-3. ISBN 9788184316445. http://books.google.gr/books?id=iQzqVqFz3IsC&pg=SA3-PA3#v=onepage&q&f=false. 
  16. «Many-to-One Model (Green Threads)». Oracle. http://docs.oracle.com/cd/E19455-01/806-3461/ch2mt-41/index.html. Ανακτήθηκε στις 29 Μαΐου 2014. 
  17. «One-to-One Model». Oracle. http://docs.oracle.com/cd/E19455-01/806-3461/ch2mt-30/index.html. Ανακτήθηκε στις 29 Μαΐου 2014. 
  18. «Many-to-Many Model (Java on Solaris--Native Threads)». Oracle. http://docs.oracle.com/cd/E19455-01/806-3461/ch2mt-31/index.html. Ανακτήθηκε στις 29 Μαΐου 2014. 
  19. Mountjoy, Jon; Chugh, Avinash (2004). Weblogic : the definitive guide ; development, deployment & maintenance ; covers versions 7 & 8.1 (1st ed. έκδοση). Beijing [u.a.]: O'Reilly. σελ. 536. ISBN 0-596-00432-X. http://books.google.gr/books?id=XaAkAfjDAT8C&pg=PT536#v=onepage&q&f=false. 


Στο λήμμα αυτό έχει ενσωματωθεί κείμενο από το λήμμα thread (computer science) της Αγγλικής Βικιπαίδειας, η οποία διανέμεται υπό την GNU FDL και την CC-BY-SA 3.0. (ιστορικό/συντάκτες).