Penyelesaian kepada pengecualian penyegerakan berbilang benang Java (ThreadSyncException)

Penyelesaian kepada pengecualian penyegerakan berbilang benang Java (ThreadSyncException)

Di Java, multi-threading ialah kaedah pengaturcaraan serentak yang biasa, tetapi ia juga membawa beberapa cabaran. Salah satu daripadanya ialah masalah penyegerakan berbilang utas Apabila berbilang utas mengakses sumber yang dikongsi pada masa yang sama, ketidakkonsistenan data atau susunan pelaksanaan yang salah mungkin berlaku. Untuk menyelesaikan masalah ini, kita perlu mengambil beberapa langkah untuk memastikan penyegerakan dan pelaksanaan berurutan antara benang. Artikel ini akan memperkenalkan beberapa penyelesaian untuk menyelesaikan pengecualian penyegerakan berbilang benang Java dan melampirkan contoh kod.

1. Gunakan kata kunci yang disegerakkan
   Kata kunci yang disegerakkan ialah mekanisme penyegerakan paling asas yang disediakan oleh Java dan boleh digunakan untuk mengubah suai kaedah dan blok kod. Apabila utas melaksanakan kod disegerakkan, utas lain perlu menunggu sehingga utas menyelesaikan pelaksanaan sebelum meneruskan. Ini memastikan bahawa hanya satu utas boleh mengakses sumber yang dikongsi pada masa yang sama, dengan itu mengelakkan masalah ketidakkonsistenan data.

Berikut ialah contoh menggunakan kata kunci yang disegerakkan untuk menyelesaikan masalah penyegerakan berbilang benang:

class Counter {
    private int count = 0;

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

    public void getCount() {
        System.out.println("Count: " + count);
    }
}

class MyThread extends Thread {
    private Counter counter;

    public MyThread(Counter counter) {
        this.counter = counter;
    }

    public void run() {
        counter.increment();
    }
}

public class Main {
    public static void main(String[] args) {
        Counter counter = new Counter();

        MyThread thread1 = new MyThread(counter);
        MyThread thread2 = new MyThread(counter);

        thread1.start();
        thread2.start();

        try {
            thread1.join();
            thread2.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        counter.getCount();
    }
}

Dalam kod di atas, kelas Kaunter mewakili pembilang, dan kaedah kenaikan diubah suai dengan kata kunci yang disegerakkan untuk memastikan bahawa hanya satu benang boleh melaksanakan kaedah pada satu masa. Kelas MyThread mewakili urutan yang menambah pembilang dengan memanggil kaedah kenaikan pembilang. Cipta dua objek MyThread dalam kelas Utama dan panggil kaedah permulaannya untuk memulakan utas. Dengan menggunakan kaedah gabungan, tunggu dua utas selesai dilaksanakan sebelum mencetak nilai pembilang.

2. Gunakan antara muka Kunci dan Keadaan
   Selain kata kunci yang disegerakkan, Java juga menyediakan antara muka Kunci dan Keadaan yang lebih fleksibel untuk menyelesaikan masalah penyegerakan berbilang benang. Berbanding dengan kata kunci yang disegerakkan, antara muka Kunci dan Keadaan memberikan kawalan yang lebih terperinci dan boleh mengawal penantian dan kebangkitan benang secara fleksibel.

Berikut ialah contoh menggunakan antara muka Kunci dan Keadaan untuk menyelesaikan masalah penyegerakan berbilang benang:

import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

class Counter {
    private int count = 0;
    private Lock lock = new ReentrantLock();
    private Condition condition = lock.newCondition();

    public void increment() {
        lock.lock();
        try {
            count++;
            condition.signalAll();
        } finally {
            lock.unlock();
        }
    }

    public void getCount() {
        System.out.println("Count: " + count);
    }
}

class MyThread extends Thread {
    private Counter counter;

    public MyThread(Counter counter) {
        this.counter = counter;
    }

    public void run() {
        counter.increment();
    }
}

public class Main {
    public static void main(String[] args) {
        Counter counter = new Counter();

        MyThread thread1 = new MyThread(counter);
        MyThread thread2 = new MyThread(counter);

        thread1.start();
        thread2.start();

        try {
            thread1.join();
            thread2.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        counter.getCount();
    }
}

Dalam kod di atas, antara muka ReentrantLock dan Condition digunakan dalam kelas Counter untuk melaksanakan kawalan penyegerakan kaunter. Kaedah kenaikan mula-mula memperoleh kunci, kemudian menambah nilai pembilang, dan membangkitkan benang menunggu melalui condition.signalAll(). Pelaksanaan dalam kelas MyThread dan kelas Utama adalah sama seperti dalam contoh di atas.

Dengan menggunakan antara muka Kunci dan Syarat, kami boleh mengawal dengan lebih fleksibel proses menunggu dan membangkitkan benang, dengan itu menyediakan kawalan penyegerakan yang lebih halus.

Ringkasan:
Pengecualian penyegerakan berbilang benang Java ialah masalah biasa dalam pengaturcaraan serentak, yang boleh diselesaikan dengan menggunakan kata kunci yang disegerakkan, antara muka Kunci dan Keadaan dan cara lain. Artikel ini menyediakan contoh kod bagi penyelesaian ini, dengan harapan dapat membantu pembaca memahami isu penyegerakan dalam pengaturcaraan serentak. Dalam pembangunan sebenar, adalah penting untuk memilih mekanisme penyegerakan yang sesuai berdasarkan keperluan dan senario tertentu.

Atas ialah kandungan terperinci Penyelesaian kepada pengecualian penyegerakan berbilang benang Java (ThreadSyncException). Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!