Fungsi synchronized dalam Java

synchronized adalah sebuah kata kunci dalam bahasa pemrograman Java yang digunakan untuk mengontrol akses ke suatu blok kode atau metode dalam lingkungan multi-threading. Sederhananya, synchronized memastikan bahwa hanya satu thread yang dapat mengeksekusi blok kode atau metode tersebut pada suatu waktu tertentu.

Mengapa synchronized Penting?

Dalam aplikasi multi-threaded, beberapa thread mungkin mencoba mengakses dan memodifikasi data yang sama secara bersamaan. Hal ini dapat menyebabkan kondisi race, di mana hasil akhir dari program menjadi tidak terprediksi dan bahkan menghasilkan data yang rusak.

Bagaimana synchronized Bekerja?

• Monitor (Lock): Setiap objek di Java secara implisit memiliki monitor (lock). Ketika sebuah thread memasuki blok kode atau metode yang disinkronkan, thread tersebut akan memperoleh lock dari objek yang terkait.
• Eksklusivitas: Selama sebuah thread memegang lock, thread lain yang mencoba memasuki blok kode atau metode yang sama akan diblokir (dibuat menunggu) hingga thread pertama melepaskan lock.
• Atomicity: Blok kode yang disinkronkan dianggap sebagai satu unit yang tidak dapat dibagi. Artinya, semua instruksi dalam blok tersebut akan dieksekusi secara lengkap tanpa gangguan dari thread lain.

Penggunaan synchronized

class ThreadSafeListManager {
    // Synchronized list to ensure thread-safe operations
    private final List<Integer> list;

    // Constructor
    public ThreadSafeListManager() {
        // Using synchronized list for thread safety
        this.list = new ArrayList<>();
    }

    // Create: Synchronized method to add an element
    public synchronized void addElement(Integer element) {
        list.add(element);
    }

    // Read: Synchronized method to get an element by index
    public synchronized Integer getElement(int index) {
        if (index >= 0 && index < list.size()) {
            return list.get(index);
        }
        throw new IndexOutOfBoundsException("Invalid index");
    }

    // Update: Synchronized method to update an element
    public synchronized void updateElement(int index, Integer newElement) {
        if (index >= 0 && index < list.size()) {
            list.set(index, newElement);
        } else {
            throw new IndexOutOfBoundsException("Invalid index");
        }
    }

    // Delete: Synchronized method to remove an element
    public synchronized void removeElement(int index) {
        if (index >= 0 && index < list.size()) {
            list.remove(index);
        } else {
            throw new IndexOutOfBoundsException("Invalid index");
        }
    }

    // Get list size
    public synchronized int getSize() {
        return list.size();
    }

    // Get all elements (return a copy to prevent external modification)
    public synchronized List<Integer> getAllElements() {
        return new ArrayList<>(list);
    }
}

kata kunci synchronized juga ada dalam Kotlin, namun penggunaannya memiliki beberapa perbedaan dan pertimbangan khusus dibandingkan dengan Java.

Perbedaan Utama:

• Depreasi: Kata kunci synchronized di Kotlin sebenarnya telah dinyatakan usang (deprecated) sejak versi 1.6 dan akan menjadi error pada versi 1.9. Ini berarti penggunaan synchronized secara langsung tidak lagi disarankan.
• Alasan Depreasi: Sinkronisasi pada objek apa pun tidak didukung dengan baik dalam Kotlin/JS, sehingga penggunaan synchronized secara universal dapat menimbulkan masalah kompatibilitas.

Alternatif di Kotlin:

Meskipun synchronized tidak lagi disarankan, Kotlin menyediakan beberapa alternatif yang lebih baik untuk menangani sinkronisasi dalam lingkungan multi-threading:

• Kotlin Coroutines: Coroutine menawarkan cara yang lebih modern dan efisien untuk menangani konkurensi dalam Kotlin. Dengan coroutine, Anda dapat mengelola tugas-tugas secara asinkron tanpa perlu khawatir tentang lock atau mutex.
• Atomic Operations: Untuk operasi atomik sederhana, Anda dapat menggunakan kelas-kelas seperti AtomicInteger, AtomicBoolean, dll. Kelas-kelas ini menyediakan metode-metode untuk melakukan operasi pertambahan, pengurangan, perbandingan, dan lainnya secara atomik.
• Mutex: Jika Anda benar-benar membutuhkan mekanisme locking yang lebih granular, Anda dapat menggunakan kelas ReentrantLock dari library Java Concurrency.

Contoh Penggunaan Alternatif:

import java.util.concurrent.atomic.AtomicInteger

class Counter {
    private val count = AtomicInteger(0)

    fun increment() {
        count.incrementAndGet()
    }
}

Dalam contoh di atas, kita menggunakan AtomicInteger untuk mengelola counter secara thread-safe tanpa perlu menggunakan synchronized.

Kapan Menggunakan Alternatif?

• Coroutine: Untuk operasi yang melibatkan penundaan atau menunggu hasil dari operasi asinkron lainnya.
• Atomic Operations: Untuk operasi sederhana yang memerlukan atomicity.
• Mutex: Untuk kasus-kasus yang lebih kompleks di mana Anda perlu mengontrol akses ke beberapa sumber daya secara bersamaan.

Mengapa Coroutine?

Coroutine menawarkan cara yang elegan untuk menangani tugas-tugas secara asinkron tanpa perlu mengelola thread secara manual. Ini membuat kode lebih mudah dibaca dan dipelihara, terutama dalam kasus-kasus yang melibatkan banyak operasi I/O atau pemrosesan yang memakan waktu lama.

Contoh Penggunaan:

Mari kita asumsikan kita memiliki MutableList berisi sejumlah data dan kita ingin memperbarui setiap elemen dalam list secara paralel, namun tetap menjaga sinkronisasi agar tidak terjadi kondisi race.

Kotlin

import kotlinx.coroutines.*
fun main() {
    val list = mutableListOf<Int>(1, 2, 3, 4, 5)

    // Coroutine scope
    runBlocking {
        // Meluncurkan sejumlah coroutine untuk memperbarui setiap elemen
        list.forEachIndexed { index, _ ->
            launch {
                delay(100) // Simulasi pekerjaan
                list[index] *= 2
                println("Elemen ke-$index telah diperbarui: ${list[index]}")
            }
        }
    }

    println("List akhir: $list")
}

Penjelasan:

1. runBlocking: Fungsi ini digunakan untuk memblokir thread utama sampai semua coroutine yang diluncurkan selesai.
2. launch: Masing-masing elemen dalam list akan memulai sebuah coroutine baru.
3. delay: Simulasi pekerjaan yang memakan waktu.
4. list[index] *= 2: Memperbarui nilai elemen pada list.
5. Sinkronisasi Implisit: Meskipun kita meluncurkan banyak coroutine, operasi pada list tetap terurut karena setiap coroutine akan menunggu gilirannya untuk mengeksekusi kode di dalam blok launch.

Mengapa ini bekerja?

• Shared Mutable State: MutableList adalah shared mutable state. Artinya, beberapa coroutine dapat mengakses dan mengubah data yang sama.
• Coroutine Context: Setiap coroutine memiliki context yang menentukan bagaimana coroutine tersebut dieksekusi. Dalam contoh ini, semua coroutine berbagi context yang sama, yaitu context dari runBlocking.
• Dispatcher: Context ini menggunakan dispatcher default, yang biasanya mengikat coroutine ke thread pool. Dispatcher ini akan mengatur eksekusi coroutine secara efisien.

Pertimbangan Tambahan:

• Konflik Sinkronisasi: Jika operasi pada list lebih kompleks dan melibatkan banyak perubahan, Anda mungkin perlu menggunakan mekanisme sinkronisasi yang lebih eksplisit seperti mutex atau atomic operation.
• Coroutine Builder: Kotlin menyediakan berbagai coroutine builder seperti async, await, withContext, dll. Anda bisa menggunakan builder yang sesuai dengan kebutuhan Anda.
• Cancellation: Anda bisa membatalkan coroutine yang sedang berjalan menggunakan fungsi cancel.

Kesimpulan:

Coroutine menawarkan cara yang sangat baik untuk menangani paralelisme dan sinkronisasi dalam Kotlin. Dengan menggunakan coroutine, Anda dapat menulis kode yang lebih bersih, lebih mudah dibaca, dan lebih efisien.

Penting:

• Hindari shared mutable state jika memungkinkan.
• Gunakan coroutine builder yang sesuai.
• Pahami konsep dispatcher dan context.

Ingin tahu lebih lanjut?

Anda bisa mencari informasi lebih lanjut mengenai:

• Kotlin Coroutines: Dokumentasi resmi Kotlin dan berbagai tutorial online.
• Shared Mutable State: Konsep fundamental dalam pemrograman konkuren.
• Dispatcher: Cara Kotlin mengatur eksekusi coroutine.