Contoh untuk memahami cara menggunakan kata kunci yang disegerakkan dalam Java

Artikel ini membawa anda pengetahuan yang berkaitan tentang java, yang terutamanya memperkenalkan isu yang berkaitan dengan kata kunci yang disegerakkan, termasuk menggunakan kaedah penyegerakan, menggunakan pernyataan penyegerakan atau blok, dan apakah penyegerakan, mengapa penyegerakan diperlukan, mari kita lihatlah, semoga bermanfaat untuk semua.

Kajian yang disyorkan: "tutorial video java"

Dalam pembangunan harian, kata kunci yang disegerakkan sering ditemui, anda tahu bagaimana disegerakkan untuk menggunakannya? Artikel ini akan memperkenalkannya kepada anda.

Kami mempunyai dua cara untuk menggunakan penyegerakan:

• Gunakan kaedah penyegerakan
• Gunakan pernyataan penyegerakan atau sekat

Gunakan kaedah penyegerakan

Untuk membuat kaedah disegerakkan, cuma tambah kata kunci yang disegerakkan pada pengisytiharannya:

public class SynchronizedDemo {

    private int i = 0;

    public synchronized void add() {
        i++;
    }

    public synchronized void del() {
        i--;
    }

    public synchronized int getValue() {
        return i;
    }
}

Seperti yang ditunjukkan dalam kod di atas, terdapat tiga kaedah yang disegerakkan secara keseluruhan :

• add()
• del()
• getValue()

Setiap kaedah hanya akan memanggil objek yang sama pada masa yang sama Apabila dipanggil sekali, contohnya, apabila utas memanggil add(), utas lain akan disekat sehingga utas pertama selesai memproses kaedah add().

Gunakan pernyataan atau blok yang disegerakkan

    public void del(int value){

        synchronized(this){
            this.i -= value;
        }
    }

Dalam kod di atas, disegerakkan ditambah sebelum kod {}, yang bermaksud ia adalah kod yang disegerakkan blok .

Di atas ialah dua cara untuk menggunakan kata kunci yang disegerakkan. Mari kita perkenalkan secara ringkas konsep yang berkaitan dengan penyegerakan.

Apakah itu penyegerakan?

Penyegerakan ialah proses mengawal akses berbilang rangkaian kepada mana-mana sumber yang dikongsi untuk mengelakkan hasil yang tidak konsisten. Tujuan utama menggunakan penyegerakan adalah untuk mengelakkan tingkah laku benang yang tidak konsisten dan mengelakkan gangguan benang.

Anda boleh menggunakan kata kunci disegerakkan dalam Java untuk mencapai kesan penyegerakan hanya boleh digunakan pada kaedah dan blok, bukan pembolehubah dan kelas.

Mengapa kita perlu menyegerakkan?

Mula-mula mari kita lihat sekeping kod:

public class SynchronizedDemo {

    int i;

    public void increment() {
        i++;
    }

    public static void main(String[] args) {
        SynchronizedDemo synchronizedDemo = new SynchronizedDemo();
        synchronizedDemo.increment();
        System.out.println("计算值为：" + synchronizedDemo.i);
    }
}

Nilai yang dikira akan dinaikkan sebanyak 1 setiap kali kaedah increment() dipanggil:

Memanggilnya 2 kali akan menambah 2, memanggilnya 3 kali akan menambah 3, memanggilnya 4 kali akan menambah 4:

public class SynchronizedDemo {

    int i;

    public void increment() {
        i++;
    }

    public static void main(String[] args) {
        SynchronizedDemo synchronizedDemo = new SynchronizedDemo();
        synchronizedDemo.increment();
        synchronizedDemo.increment();
        synchronizedDemo.increment();
        synchronizedDemo.increment();
        System.out.println("计算值为：" + synchronizedDemo.i);
    }
}

Sekarang mari kita kembangkan contoh di atas , buat benang untuk memanggil kaedah increment() 10 kali:

public class SynchronizedDemo {

    int i;

    public void increment() {
        i++;
    }

    public static void main(String[] args) {
        SynchronizedDemo synchronizedDemo = new SynchronizedDemo();
        Thread thread = new Thread(() -> {
            for (int i = 1; i <= 10; i++) {
                synchronizedDemo.increment();
            }
        });
        thread.start();
        try {
            thread.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("计算值为：" + synchronizedDemo.i);
    }
}

Hasil yang dikira pada masa ini adalah seperti yang kita jangkakan, hasilnya ialah 10.

Ini adalah situasi satu benang, semuanya sangat baik, tetapi adakah ia benar-benar berlaku? Apakah rupanya jika ia adalah persekitaran berbilang benang?

Jom tunjukkan situasi pelbagai benang!

public class SynchronizedDemo {

    int i;

    public void increment() {
        i++;
    }

    public static void main(String[] args) {
        SynchronizedDemo synchronizedDemo = new SynchronizedDemo();

        Thread thread1 = new Thread(() -> {
            for (int i = 1; i <= 1000; i++) {
                synchronizedDemo.increment();
            }
        });

        Thread thread2 = new Thread(() -> {
            for (int i = 1; i <= 1000; i++) {
                synchronizedDemo.increment();
            }
        });

        thread1.start();
        thread2.start();
        try {
            thread1.join();
            thread2.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("计算值为：" + synchronizedDemo.i);
    }
}

Seperti yang ditunjukkan dalam kod di atas, kami mencipta dua utas thread1 dan thread2 Setiap thread memanggil increment() 1000 kali secara teori, nilai cetakan akhir hendaklah 2000. kerana thread1 Selepas memanggil increment() 1000 kali, nilai akan menjadi 1000. Selepas thread2 memanggil increment() 1000 kali, nilai akan menjadi 2000.

Mari kita laksanakan dan lihat hasilnya:

Hasilnya berbeza dari apa yang kita sangka, kurang dari 2000. Jom laksanakan lagi:

Hasilnya masih kurang daripada 2000.

Ini Sebabnya?

Oleh sebab multi-threading menyokong pemprosesan selari, dua utas sentiasa mungkin untuk mendapatkan nilai pembilang pada masa yang sama, dan oleh itu kedua-duanya mendapat nilai pembilang yang sama, jadi dalam kes ini, bukannya menambah nilai kaunter dua kali, hanya meningkat sekali.

Jadi, bagaimana untuk mengelakkan situasi ini?

Gunakan kata kunci yang disegerakkan untuk menyelesaikan masalah ini.

Kami hanya perlu menambah disegerakkan pada kaedah increment():

public class SynchronizedDemo {

    int i;

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

    public static void main(String[] args) {
        SynchronizedDemo synchronizedDemo = new SynchronizedDemo();

        Thread thread1 = new Thread(() -> {
            for (int i = 1; i <= 1000; i++) {
                synchronizedDemo.increment();
            }
        });

        Thread thread2 = new Thread(() -> {
            for (int i = 1; i <= 1000; i++) {
                synchronizedDemo.increment();
            }
        });

        thread1.start();
        thread2.start();
        try {
            thread1.join();
            thread2.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("计算值为：" + synchronizedDemo.i);
    }
}

Pada masa ini kami akan melaksanakannya semula:

Seperti yang anda lihat, nilainya ialah 2000.

Kami meningkatkan bilangan pengiraan kepada 10,000 kali ganda:

public class SynchronizedDemo {

    int i;

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

    public static void main(String[] args) {
        SynchronizedDemo synchronizedDemo = new SynchronizedDemo();

        Thread thread1 = new Thread(() -> {
            for (int i = 1; i <= 10000; i++) {
                synchronizedDemo.increment();
            }
        });

        Thread thread2 = new Thread(() -> {
            for (int i = 1; i <= 10000; i++) {
                synchronizedDemo.increment();
            }
        });

        thread1.start();
        thread2.start();
        try {
            thread1.join();
            thread2.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("计算值为：" + synchronizedDemo.i);
    }
}

Hasil pelaksanaan ialah:

Dapat dilihat bahawa sedikit segerak menyelesaikan masalah ini dengan mudah.

Prinsip di sebalik ini ialah apabila utas 1 melaksanakan kaedah increment(), kerana ia disegerakkan, kaedah ini akan dikunci secara automatik Pada masa ini, hanya utas 1 yang mempunyai kunci ini dan utas lain hanya boleh menunggu sehingga utas 1 Lepaskan kunci ini supaya utas 2 boleh mengambil bahagian dalam panggilan.

Begitu juga, apabila thread 2 memanggil increment(), thread 2 mendapat kunci, dan thread 1 menunggu sehingga thread 2 melepaskan kunci Dengan cara ini, sehingga pengiraan selesai, semasa proses ini, akan ada tiada Ralat pengiraan telah berlaku.

Ringkasan

• Kata kunci disegerakkan ialah satu-satunya cara untuk membuat blok atau kaedah disegerakkan.
• Kata kunci yang disegerakkan menyediakan ciri penguncian, yang memastikan keadaan perlumbaan tidak berlaku antara benang. Selepas dikunci, benang hanya boleh membaca data dari ingatan utama Selepas membaca data, ia mengepam operasi tulis sebelum ia boleh melepaskan kunci.
• Kata kunci yang disegerakkan juga membantu mengelakkan penyusunan semula pernyataan program.

Pembelajaran yang disyorkan: "tutorial video java"

Atas ialah kandungan terperinci Contoh untuk memahami cara menggunakan kata kunci yang disegerakkan dalam Java. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!