"Hai, Amigo!"
"Ya, aku di sini, aku di sini."
"Hari ini, saya akan memberi tahu Anda tentang penggunaan sinkronisasi dalam praktik."
"Ketika sebuah program memiliki banyak objek dan utas, sering terjadi beberapa utas bekerja dengan objek yang sama secara bersamaan. Dengan demikian, utas saling mengganggu."
"Ya, aku sudah tahu ini."
"Jadi, katakanlah Anda memiliki objek yang diakses oleh banyak utas. Anda dapat melakukan dua hal untuk menghindari masalah."
"Yang pertama adalah menggunakan blok tersinkronisasi untuk membungkus setiap lokasi tempat objek diakses. Namun pendekatan ini mungkin tidak berfungsi jika beberapa pemrogram menulis kode yang mengakses objek secara langsung, tanpa blok tersinkronisasi."
"Oleh karena itu, pendekatan kedua paling sering digunakan—membuat objek menjadi thread-safe." "Dengan kata lain, mekanisme tersinkronisasi dibangun ke dalam objek itu sendiri: ia mendeklarasikan metodenya tersinkronisasi dan/atau membungkus kode di dalam metodenya dalam blok tersinkronisasi."
"Jadi, objek apa pun yang mungkin saya gunakan dari banyak utas, dan ini hampir semua objek dalam program, saya harus membuat thread-safe?"
"Secara umum ya. Pada kenyataannya, tidak semua objek dalam suatu program digunakan oleh utas yang berbeda, tetapi biasanya ada banyak. Jadi, ketika Anda mulai menulis kode untuk utas dan mengakses berbagai objek darinya, maka dengan setiap pemanggilan metode Anda harus bertanya pada diri sendiri, «Apakah panggilan ini aman?»"
"Aman?"
"Thread-safe, artinya dapat dipanggil dengan aman dari banyak utas."
"Berikut adalah beberapa contoh. Misalkan Anda memiliki objek String yang diakses dari thread yang berbeda. Seperti yang seharusnya Anda ingat, String tidak dapat diubah — seperti semua tipe primitif lainnya. Ini berarti bahwa objek tidak berubah setelah dibuat . Ini berarti tidak mungkin untuk «memecahkan» objek seperti itu. Semua objek yang tidak dapat diubah adalah thread-safe."
"Yah, itu membuat segalanya lebih mudah."
"Sekarang, misalkan Anda membutuhkan string yang bisa berubah."
"Ya, saya ingat. Ada dua jenis string seperti itu: StringBuffer dan StringBuilder. StringBuffer seperti StringBuilder, tetapi semua metodenya disinkronkan. Apakah ini juga aman untuk thread?"
"Ya. Jika Anda perlu mengakses objek StringBuilder dari banyak utas, Anda harus menggantinya dengan StringBuffer. Jika tidak, cepat atau lambat utas akan mengubahnya pada saat yang sama dan «merusak» itu."
"Bagaimana jika objek yang diakses dari utas berbeda adalah objek dari kelas saya sendiri? Apakah saya perlu menambahkan metode yang disinkronkan dalam kasus ini juga?"
"Ya. Sebaiknya ikuti aturan ini: semua objek yang akan diakses dari utas berbeda harus aman dari utas."
"Begitu. Kupikir semuanya tidak seserius ini. Terima kasih, Ellie."
"Sama-sama. Saya harap tips ini akan membantu Anda ketika Diego memberi Anda beberapa tugas mudahnya. ☺"