Πώς μπορεί να υλοποιηθεί ο συγχρονισμός σε Kotlin…

Ο συγχρονισμός σε Kotlin coroutines επιτυγχάνεται με τη βοήθεια ειδικών primitive και δομών δεδομένων από τη βιβλιοθήκη kotlinx.coroutines.

Κύριες προσεγγίσεις:

Mutex

Παρέχει αμοιβαία εξαίρεση για την προστασία κρίσιμων τμημάτων κώδικα.
Μια coroutine που προσπαθεί να αποκτήσει ένα Mutex μπλοκάρεται μέχρι να ελευθερωθεί.
Διαθέτει τις λειτουργίες lock() και unlock(), καθώς και το πιο ιδιωματικό withLock.

import kotlinx.coroutines.sync.Mutex
import kotlinx.coroutines.sync.withLock
import kotlinx.coroutines.*

val mutex = Mutex()
var counter = 0

suspend fun increment() {
    mutex.withLock {
        counter++
    }
}

suspend fun main() = coroutineScope {
    repeat(10_000) {
        launch {
            increment()
        }
    }
    println(counter) // Αναμένουμε 10000
}

Semaphore

Περιορίζει τον αριθμό των coroutine που μπορούν ταυτόχρονα να έχουν πρόσβαση σε πόρο ή να εκτελέσουν ένα συγκεκριμένο μπλοκ κώδικα.
Διαχειρίζεται μια ομάδα αδειών.
Διαθέτει τις λειτουργίες acquire() και release(), καθώς και το withPermit.

import kotlinx.coroutines.sync.Semaphore
import kotlinx.coroutines.sync.withPermit
import kotlinx.coroutines.*

val semaphore = Semaphore(2) // Ταυτόχρονα μπορούν να λειτουργούν 2 coroutine

suspend fun doLimitedWork(id: Int) {
    semaphore.withPermit {
        println("Corutina $id απέκτησε άδεια. Δουλεύει...")
        delay(100) // Μίμηση εργασίας
        println("Corutina $id απελευθέρωσε άδεια.")
    }
}

suspend fun main() = coroutineScope {
    repeat(5) { i ->
        launch {
            doLimitedWork(i)
        }
    }
}

Ατομικές λειτουργίες (από kotlinx.coroutines.atomic)
- Παρέχουν ασφαλείς για νηματικές λειτουργίες πάνω σε primitive τύπους και αναφορές.
- Χρησιμοποιούν χαμηλού επιπέδου εντολές CPU (CAS - Compare-and-Swap).
- Κατάλληλες για απλές λειτουργίες χωρίς εμφανείς μπλοκαρίσματα.
```
import kotlinx.coroutines.atomic.AtomicInt
import kotlinx.coroutines.*

val atomicCounter = AtomicInt(0)

suspend fun atomicIncrement() {
    atomicCounter.incrementAndGet()
}

suspend fun main() = coroutineScope {
    repeat(10_000) {
        launch {
            atomicIncrement()
        }
    }
    println(atomicCounter.value) // Αναμένουμε 10000
}
```
Κοινά δεδομένα σε dispatcher μονοπύρηνης επεξεργασίας
- Η πιο απλή προσέγγιση. Η εκτέλεση coroutine σε ένα μονοπύρηνο πλαίσιο (Dispatchers.Default.limitedParallelism(1) ή newSingleThreadContext) εγγυάται την διαδοχική εκτέλεση του κώδικα, αποφεύγοντας συγκρούσεις δεδομένων. Δεν αποτελεί εμφανές primitive συγχρονισμού, αλλά διασφαλίζει συγχρονισμό μέσω σειριοποίησης της πρόσβασης.
```
import kotlinx.coroutines.*

val mySingleThreadContext = newSingleThreadContext("SingleThread")
var sharedData = mutableListOf<Int>()

suspend fun addToSharedData(value: Int) {
    sharedData.add(value) // Ασφαλές, καθώς εκτελείται σε ένα νήμα
}

suspend fun main() = withContext(mySingleThreadContext) {
    repeat(10_000) {
        launch {
             addToSharedData(it)
        }
    }
    println(sharedData.size) // Αναμένουμε 10000
}
```
Κανάλια
- Δεν είναι primitive συγχρονισμού καθαυτά, αλλά μπορούν να χρησιμοποιηθούν για ασφαλή μεταφορά δεδομένων μεταξύ coroutine, λύνοντας έμμεσα προβλήματα συγχρονισμού πρόσβασης στα δεδομένα.
- Παρέχουν τρόπο μεταφοράς ροής δεδομένων από μια coroutine σε άλλη.

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

Πώς μπορεί να υλοποιηθεί ο συγχρονισμός σε Kotlin χρησιμοποιώντας coroutines;