This shows you the differences between two versions of the page.
|
java:synchronized_methods_blocks [2018/03/08 11:15] gthanos [Συγχρονισμένα Βlocks] |
java:synchronized_methods_blocks [2018/03/08 12:03] |
||
|---|---|---|---|
| Line 1: | Line 1: | ||
| - | ====== Συγχρονισμένες μέθοδοι και συγχρονισμένα blocks ====== | ||
| - | |||
| - | Η Java παρέχει δύο βασικούς τρόπους συγχρονισμού προκειμένου να αποφεύγονται τα προβλήματα συγχρονισμού που παρουσιάστηκαν προηγούμενα **α)** τις συγχρονισμένες μεθόδους και **β)** τα συγχρονισμένα blocks. | ||
| - | |||
| - | Η διαδικασίες συγχρονισμού που περιγράφονται παρακάτω βασίζονται σε έναν εσωτερικό μηχανισμό που διαθέτουν όλα τα αντικείμενα στην Java, το λεγόμενο //intrinsic lock// ή //monitor lock// ή // | ||
| - | |||
| - | Όταν ένα νήμα θέλει να εκτελέσει τη συγχρονισμένη μέθοδο ενός αντικειμένου θα πρέπει να λάβει το //monitor lock// για το αντικείμενο αυτό. Αντίστοιχα, | ||
| - | |||
| - | ===== Συγχρονισμένες μέθοδοι ===== | ||
| - | |||
| - | Προκειμένου να δημιουργήσετε μία συγχρονισμένη μέθοδο σε μία κλάση αρκεί να προσθέσετε το keyword // | ||
| - | |||
| - | <code java SynchronizedCounter.java> | ||
| - | public class SynchronizedCounter { | ||
| - | private int c = 0; | ||
| - | |||
| - | public synchronized void increment() { | ||
| - | c++; | ||
| - | } | ||
| - | |||
| - | public synchronized void decrement() { | ||
| - | c--; | ||
| - | } | ||
| - | |||
| - | public synchronized int value() { | ||
| - | return c; | ||
| - | } | ||
| - | } | ||
| - | </ | ||
| - | |||
| - | Αν έχουμε ένα αντικείμενο //counter// της παραπάνω κλάσης τότε ισχύουν τα παρακάτω | ||
| - | * Δεν είναι δυνατόν η ίδια συγχρονισμένη μέθοδος ή διαφορετικές συγχρονισμένες μέθοδοι ενός αντικειμένου να κληθούν ταυτόχρονα από διαφορετικά νήματα. Ας υποθέσουμε ότι ένα νήμα εκτελεί μία από τις συγχρονισμένες μεθόδους ενός αντικειμένου. Όσα άλλα νήματα επιχειρούν να έχουν πρόσβαση σε συγχρονισμένες μεθόδους του ιδίου αντικειμένου, | ||
| - | |||
| - | ===== Συγχρονισμένα Βlocks ===== | ||
| - | |||
| - | Σε αναλογία με τις συγχρονισμένες μεθόδους ορίζονται και τα συγχρονισμένα blocks με την διαφορά ότι τα συγχρονισμένα blocks οφείλουν να ορίσουν το αντικείμενο του οποίου λαμβάνουν το //monitor lock//, όπως παρακάτω | ||
| - | |||
| - | <code java> | ||
| - | public class SynchronizedCounter { | ||
| - | private int c = 0; | ||
| - | public void increment() { synchronized (this) {c++;} } | ||
| - | public void decrement() { synchronized (this) {c--;} } | ||
| - | public int value() { synchronized (this) {return c;} } | ||
| - | } | ||
| - | </ | ||
| - | |||
| - | Στο παρακάτω παράδειγμα έχουμε δύο συγχρονισμένα blocκ μέσα σε δύο μη συγχρονισμένες μεθόδους. Η διαφορά είναι ότι η κλάση ορίζει δύο επιπλέον αντικείμενα μόνο και μόνο για να χρησιμοποιήσει τα //monitor locks// των αντικειμένων αυτών | ||
| - | |||
| - | <code java SyncBlock.java> | ||
| - | public class SyncBlock { | ||
| - | private long c1 = 0; | ||
| - | private long c2 = 0; | ||
| - | private Object lock1 = new Object(); | ||
| - | private Object lock2 = new Object(); | ||
| - | |||
| - | public void inc1() { | ||
| - | synchronized(lock1) { | ||
| - | while(true) { | ||
| - | | ||
| - | ; | ||
| - | | ||
| - | } | ||
| - | } | ||
| - | } | ||
| - | |||
| - | public void inc2() { | ||
| - | synchronized(lock2) { | ||
| - | while(true) { | ||
| - | | ||
| - | ; | ||
| - | | ||
| - | } | ||
| - | } | ||
| - | } | ||
| - | } | ||
| - | </ | ||
| - | |||
| - | <WRAP tip 80% round center> | ||
| - | Αν και ένα νήμα δεν μπορεί να λάβει το //monitor lock// ενός αντικειμένου, | ||
| - | </ | ||
| - | |||
| - | <WRAP important 80% round center> | ||
| - | Στο παραπάνω παράδειγμα, | ||
| - | </ | ||
| - | |||
| - | <code java SyncBlockThread.java> | ||
| - | public class SyncBlockThread extends Thread { | ||
| - | SyncBlock block; | ||
| - | boolean counter1; | ||
| - | public SyncBlockThread(SyncBlock block, boolean counter1) { | ||
| - | this.block = block; | ||
| - | this.counter1 = counter1; | ||
| - | } | ||
| - | | ||
| - | public void run() { | ||
| - | if(counter1) | ||
| - | block.inc1(); | ||
| - | else | ||
| - | block.inc2(); | ||
| - | } | ||
| - | | ||
| - | public static void main(String []args) { | ||
| - | SyncBlock block = new SyncBlock(); | ||
| - | new SyncBlockThread(block, | ||
| - | new SyncBlockThread(block, | ||
| - | } | ||
| - | } | ||
| - | </ | ||
| - | |||
| - | Δείτε το παρακάτω παράδειγμα εμφωλευμένων κλήσεων συγχρονισμένων μεθόδων | ||
| - | |||
| - | <code java NestedSyncMethods.java> | ||
| - | public class NestedSyncMethods { | ||
| - | void synchronized outer() { | ||
| - | inner(); | ||
| - | } | ||
| - | | ||
| - | void synchronized inner() { | ||
| - | ... | ||
| - | } | ||
| - | } | ||
| - | </ | ||
| - | |||
| - | <WRAP round center tip 80%> | ||
| - | Αναφέρθηκε παραπάνω ότι μόνο ένα νήμα λαμβάνει το //monitor lock// ενός αντικειμένου προκειμένου να εκτελέσει το συγχρονισμένο block ή την συγχρονισμένη μέθοδο που συνδέεται με το αντικείμενο αυτό. Τα υπόλοιπα νήματα που πιθανόν θέλουν και εκείνα να προσπελάσουν τη συγκεκριμένη μέθοδο ή block βρίσκονται σε κατάσταση // | ||
| - | </ | ||
| - | |||
| - | |||
| - | |||