Τι είναι το deadlock;

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

Οι συνθήκες εμφάνισης ενός deadlock (συνθήκες Coffman):

1. Αμοιβαία εξαίρεση (Mutual Exclusion): Οι πόροι δεν μπορούν να χρησιμοποιηθούν ταυτόχρονα από πολλά νήματα.
2. Διατήρηση και αναμονή (Hold and Wait): Τα νήματα που ήδη κατέχουν έναν πόρο περιμένουν να αποκτήσουν έναν άλλο πόρο που κατέχεται από άλλο νήμα.
3. Χωρίς προεπιλογή (No Preemption): Ένας πόρος δεν μπορεί να αφαιρεθεί βίαια από ένα νήμα που τον κατέχει; μπορεί να απελευθερωθεί μόνο από το ίδιο το νήμα.
4. Κυκλική αναμονή (Circular Wait): Υπάρχει μια αλυσίδα δύο ή περισσότερων νημάτων όπου κάθε νήμα περιμένει έναν πόρο που κατέχεται από το επόμενο νήμα στην αλυσίδα (κυκλική αναμονή).

Ένα απλό παράδειγμα deadlock:

Δύο νήματα, δύο πόροι (A και B).

• Το νήμα 1 καταλαμβάνει τον πόρο A.
• Το νήμα 2 καταλαμβάνει τον πόρο B.
• Το νήμα 1 προσπαθεί να καταλάβει τον πόρο B (που κατέχεται από το νήμα 2).
• Το νήμα 2 προσπαθεί να καταλάβει τον πόρο A (που κατέχεται από το νήμα 1).

Τα δύο νήματα είναι μπλοκαρισμένα για πάντα.

// Απλό παράδειγμα προσομοίωσης deadlock με χρήση lock
object resourceA = new object();
object resourceB = new object();

void Thread1Method()
{
    lock (resourceA) // Το νήμα 1 καταλαμβάνει A
    {
        Console.WriteLine("Το νήμα 1 κατέχει πόρο A");
        Thread.Sleep(100); // Μικρή καθυστέρηση για επίδειξη δυνατότητας αλλαγής νημάτων
        lock (resourceB) // Το νήμα 1 προσπαθεί να καταλάβει B
        {
            Console.WriteLine("Το νήμα 1 κατέχει πόρο B");
        }
    }
}

void Thread2Method()
{
    lock (resourceB) // Το νήμα 2 καταλαμβάνει B
    {
        Console.WriteLine("Το νήμα 2 κατέχει πόρο B");
        Thread.Sleep(100); // Μικρή καθυστέρηση
        lock (resourceA) // Το νήμα 2 προσπαθεί να καταλάβει A
        {
            Console.WriteLine("Το νήμα 2 κατέχει πόρο A");
        }
    }
}

// Η δημιουργία και εκκίνηση νημάτων μπορεί να οδηγήσει σε deadlock.
// new Thread(Thread1Method).Start();
// new Thread(Thread2Method).Start();

// Η εκτέλεση αυτού του κώδικα μπορεί, αλλά δεν είναι απαραίτητο, να δείξει deadlock,
// καθώς η σειρά εκτέλεσης εξαρτάται από το scheduler.
// Αν το νήμα 1 καταλάβει το A και το νήμα 2 το B πριν το πρώτο
// καταφέρει να καταλάβει το B, θα προκύψει deadlock.

Η αποτροπή deadlock συχνά επιτυγχάνεται με:

• Ταξινόμηση της απόκτησης πόρων (πάντα να αποκτούνται οι πόροι με την ίδια σειρά).
• Χρήση μεθόδων απόκτησης με χρονικό όριο (προσπάθεια απόκτησης πόρου εντός ορισμένου χρόνου).
• Σχεδιασμός χωρίς την ανάγκη διατήρησης πολλαπλών κλειδώσεων ταυτόχρονα.
• Χρήση ατομικών λειτουργιών ή ανώτερων primitive συγχρονισμού (π.χ., Monitor.TryEnter, ReaderWriterLockSlim).

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