Bagaimana untuk menyelesaikan isu perbalahan dan perbalahan benang di Jawa

Cara menyelesaikan isu perbalahan dan perbalahan dalam Java, contoh kod khusus diperlukan

Isu perbalahan dan perbalahan adalah cabaran biasa apabila membangunkan aplikasi berbilang benang. Apabila berbilang rangkaian mengakses dan mengubah suai sumber dikongsi pada masa yang sama, ketidakkonsistenan data atau hasil jalan yang salah mungkin berlaku. Untuk menyelesaikan masalah ini, Java menyediakan pelbagai mekanisme dan alatan untuk menyegerakkan benang dan memastikan keselamatan benang dan pelaksanaan yang betul.

1. Gunakan kata kunci yang disegerakkan untuk mencapai penyegerakan utas
Kata kunci yang disegerakkan boleh menandakan blok atau kaedah kod sebagai disegerakkan Hanya satu utas dibenarkan untuk memasuki blok yang disegerakkan atau kaedah yang disegerakkan pada masa yang sama, dan utas lain akan disekat. . Ini memastikan sumber yang dikongsi hanya diakses oleh satu utas pada masa yang sama, mengelakkan persaingan benang dan masalah perbalahan.

Berikut ialah contoh kod menggunakan kata kunci disegerakkan:

public class ThreadDemo implements Runnable{
    private static int count = 0;

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

    @Override
    public void run() {
        for(int i=0; i<1000; i++){
            increment();
        }
    }

    public static void main(String[] args) throws InterruptedException {
        ThreadDemo threadDemo = new ThreadDemo();
        Thread t1 = new Thread(threadDemo);
        Thread t2 = new Thread(threadDemo);
        t1.start();
        t2.start();
        t1.join();
        t2.join();
        System.out.println(count);
    }
}

Dalam kod di atas, kami menggunakan kata kunci disegerakkan untuk mengubah suai kaedah increment() untuk memastikan akses kepada pembolehubah kiraan adalah saling eksklusif. Apabila dua utas mengakses kaedah increment() pada masa yang sama, hanya satu utas boleh mendapatkan kunci dan melaksanakan kaedah tersebut, dan utas lain akan disekat.

2. Gunakan antara muka Lock untuk mencapai penyegerakan benang
Selain kata kunci yang disegerakkan, Java juga menyediakan antara muka Lock dan kelas pelaksanaannya untuk mencapai penyegerakan benang. Berbanding dengan kata kunci yang disegerakkan, antara muka Lock menyediakan kawalan yang lebih fleksibel dan lebih halus.

Berikut ialah contoh kod menggunakan antara muka Lock:

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

public class ThreadDemo implements Runnable{
    private static int count = 0;
    private static Lock lock = new ReentrantLock();

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

    @Override
    public void run() {
        for(int i=0; i<1000; i++){
            increment();
        }
    }

    public static void main(String[] args) throws InterruptedException {
        ThreadDemo threadDemo = new ThreadDemo();
        Thread t1 = new Thread(threadDemo);
        Thread t2 = new Thread(threadDemo);
        t1.start();
        t2.start();
        t1.join();
        t2.join();
        System.out.println(count);
    }
}

Dalam kod di atas, kami menggunakan kelas pelaksanaan ReentrantLock antara muka Lock untuk mencipta kunci objek kunci. Dalam kaedah increment(), kami mula-mula memanggil kaedah lock() untuk memperoleh kunci, dan memanggil kaedah unlock() dalam blok akhirnya untuk melepaskan kunci. Ini memastikan bahawa kunci dilepaskan dengan betul dalam apa jua keadaan.

3. Gunakan kelas Atomic untuk mencapai keselamatan benang
Selain menggunakan kunci untuk menyegerakkan benang, Java juga menyediakan beberapa kelas atom, seperti AtomicInteger, AtomicLong, dll., yang menyediakan beberapa operasi atom untuk memastikan keselamatan benang.

Berikut ialah contoh kod menggunakan kelas Atomic:

import java.util.concurrent.atomic.AtomicInteger;

public class ThreadDemo implements Runnable{
    private static AtomicInteger count = new AtomicInteger(0);

    public void increment(){
        count.incrementAndGet();
    }

    @Override
    public void run() {
        for(int i=0; i<1000; i++){
            increment();
        }
    }

    public static void main(String[] args) throws InterruptedException {
        ThreadDemo threadDemo = new ThreadDemo();
        Thread t1 = new Thread(threadDemo);
        Thread t2 = new Thread(threadDemo);
        t1.start();
        t2.start();
        t1.join();
        t2.join();
        System.out.println(count.get());
    }
}

Dalam kod di atas, kami menggunakan kelas AtomicInteger untuk menggantikan pembolehubah jenis int biasa, dan menambah kiraan dengan memanggil kaedah incrementAndGet(). Oleh kerana operasi kenaikan kelas AtomicInteger adalah atom, ia boleh memastikan keselamatan benang.

Ringkasnya, untuk menyelesaikan masalah persaingan benang dan pertikaian dalam Java, anda boleh menggunakan mekanisme dan alatan seperti kata kunci yang disegerakkan, antara muka Kunci atau kelas Atomic. Pembangun boleh memilih kaedah yang sesuai berdasarkan senario tertentu untuk memastikan keselamatan benang dan pelaksanaan yang betul.

Atas ialah kandungan terperinci Bagaimana untuk menyelesaikan isu perbalahan dan perbalahan benang di Jawa. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!