Java - Penyegerakan Blok

Hai di sana, para penyihir Java masa depan! ? Hari ini, kita akan melakukan perjalanan yang menarik ke atas dunia Penyegerakan Blok Java. Jangan khawatir jika kamu baru untuk pemrograman; Saya akan memandu kamu melalui topik ini langkah demi langkah, sama seperti yang saya lakukan untuk pelbagai pelajar selama tahun penyelajaran saya. Jadi, ambil minuman kesukaan kamu, kenaikan yang selesa dan mari kita melompat masuk!

Memahami Dasar-dasar

Sebelum kita melompat ke penyegerakan blok, mari kita secara cepat mengulas beberapa konsep fundamental. Bayangkan kamu di atas dapur dengan kawan-kawan kamu, semua cuba untuk memasak makanan bersama-sama. Itu adalah seperti beberapa thread di Java bekerja bersama-sama dalam program. Kadang-kadang, kamu perlu untuk koordinasi untuk mengelakkan kericuhan – itulah di mana penyegerakan datang!

Apa itu Multithreading?

Multithreading adalah seperti memiliki beberapa penyajik di atas dapur, masing-masing bekerja pada tugas yang berbeza secara serentak. Di Java, penyajik ini dipanggil thread, dan mereka membolehkan program kita untuk melakukan beberapa hal pada saat yang sama.

Mengapa Kita Perlu Penyegerakan?

Gambarkan ini: Kamu dan rakan kamu kedua-dua mencapai rak penyiram garam pada saat yang sama. Ups! Itu adalah "kondisi lomba" dalam istilah pemrograman. Penyegerakan membantu mengelakkan konflik ini dengan memastikan hanya satu thread yang boleh mengakses sumber bersama pada satu masa.

Penyegerakan Blok di Java

Sekarang, mari kita tumpu pada topik utama kami: Penyegerakan Blok. Itu adalah cara untuk memastikan hanya satu thread yang boleh menjalankan blok kode khusus pada satu masa.

Bagaimana Cara Kerjanya?

Penyegerakan blok menggunakan kata kunci synchronized diikuti dengan kurung kurawal yang mengandungi objek yang menjadi kunci penyegerakan. Hanya satu thread yang boleh memegang kunci ini pada satu masa, memastikan akses eksklusif ke blok yang disegerakkan.

Mari lihat contoh yang simple:

public class Counter {
private int count = 0;

public void increment() {
synchronized(this) {
count++;
}
}

public int getCount() {
return count;
}
}

Dalam contoh ini, metode increment() menggunakan penyegerakan blok. Kata kunci this merujuk kepada objek saat ini, yang bertindak sebagai kunci.

Mengapa Menggunakan Penyegerakan Blok?

Penyegerakan blok adalah lebih fleksibel daripada penyegerakan aras metode. Itu membolehkan kamu untuk menyegerakkan hanya beberapa bagian kritikal kod kamu, yang mungkin meningkatkan prestasi.

Contoh Multithreading tanpa Penyegerakan

Mari lihat apa yang terjadi jika kita tidak menggunakan penyegerakan:

public class UnsafeCounter {
private int count = 0;

public void increment() {
count++;
}

public int getCount() {
return count;
}

public static void main(String[] args) throws InterruptedException {
UnsafeCounter counter = new UnsafeCounter();
Thread t1 = new Thread(() -> {
for (int i = 0; i < 1000; i++) {
counter.increment();
}
});
Thread t2 = new Thread(() -> {
for (int i = 0; i < 1000; i++) {
counter.increment();
}
});

t1.start();
t2.start();
t1.join();
t2.join();

System.out.println("Count akhir: " + counter.getCount());
}
}

Jika kamu menjalankan kod ini beberapa kali, kamu mungkin akan mendapat hasil yang berbeza, dan jarang 2000. Ini adalah kerana thread tersebut mengganggu operasi satu sama lain.

Contoh Multithreading dengan Penyegerakan di Aras Blok

Sekarang, mari kita perbaiki counter kita menggunakan penyegerakan blok:

public class SafeCounter {
private int count = 0;
private Object lock = new Object(); // Kita akan menggunakan ini sebagai kunci penyegerakan

public void increment() {
synchronized(lock) {
count++;
}
}

public int getCount() {
return count;
}

public static void main(String[] args) throws InterruptedException {
SafeCounter counter = new SafeCounter();
Thread t1 = new Thread(() -> {
for (int i = 0; i < 1000; i++) {
counter.increment();
}
});
Thread t2 = new Thread(() -> {
for (int i = 0; i < 1000; i++) {
counter.increment();
}
});

t1.start();
t2.start();
t1.join();
t2.join();

System.out.println("Count akhir: " + counter.getCount());
}
}

Kini, tidak kira berapa kali kamu menjalankan ini, kamu akan mendapat 2000 sebagai jumlah akhir. Itu adalah kekuatan penyegerakan!

Contoh Multithreading dengan Penyegerakan di Aras Metode

Untuk perbandingan, ini cara kita dapatkan hasil yang sama menggunakan penyegerakan aras metode:

public class MethodSynchronizedCounter {
private int count = 0;

public synchronized void increment() {
count++;
}

public int getCount() {
return count;
}

public static void main(String[] args) throws InterruptedException {
MethodSynchronizedCounter counter = new MethodSynchronizedCounter();
Thread t1 = new Thread(() -> {
for (int i = 0; i < 1000; i++) {
counter.increment();
}
});
Thread t2 = new Thread(() -> {
for (int i = 0; i < 1000; i++) {
counter.increment();
}
});

t1.start();
t2.start();
t1.join();
t2.join();

System.out.println("Count akhir: " + counter.getCount());
}
}

Pendekatan ini juga berfungsi, tetapi ia menyegerakkan keseluruhan metode, yang mungkin terlalu berlebihan jika hanya beberapa bagian kecil metode yang perlu penyegerakan.

Membandingkan Teknik Penyegerakan

Berikut adalah perbandingan cepat untuk teknik penyegerakan yang kita diskusikan:

Teknik	Kelebihan	Kekurangan
Tanpa Penyegerakan	Cepat, tetapi tidak selamat untuk sumber bersama	Boleh menyebabkan kondisi lomba dan hasil yang tidak konsisten
Penyegerakan Blok	Kontrol halus, potensi prestasi yang lebih baik	Memerlukan penempatan penyegerakan blok dengan hati-hati
Penyegerakan Metode	Mudah untuk melaksanakan	Mungkin mengesegerakan terlalu banyak, potensi mengurangkan prestasi

Kesimpulan

Dan itu adalah, rakan-rakan! Kita telah melakukan perjalanan melalui negeri Penyegerakan Blok Java. Ingat, penyegerakan adalah seperti rakit penyinaran di atas kota yang sibuk – itu membantu mengurus aliran dan mengelakkan kecelakaan. Gunakannya dengan bijak, dan program multithreaded kamu akan berjalan dengan lancar dan selamat.

Sebagai kamu teruskan petualangan Java kamu, terus untuk praktikkan konsep ini. Cuba untuk membuat aplikasi multithreaded kamu sendiri dan eksperimen dengan teknik penyegerakan yang berbeza. Siapa tahu? Kamu mungkin hanya membuat aplikasi multithreaded yang berubah dunia berikutnya!

Happy coding, dan may threads kamu selalu di atas sync! ?

Credits: Image by storyset