Bagaimana untuk melaksanakan pengaturcaraan serentak menggunakan multithreading di Java?

Bagaimana untuk melaksanakan pengaturcaraan serentak menggunakan multi-threading dalam Java?

Dalam pembangunan pemproses komputer moden, kami telah melihat kemunculan pemproses berbilang teras, yang memberikan lebih banyak kemungkinan untuk pengaturcaraan serentak. Sebagai bahasa pengaturcaraan yang digunakan secara meluas, Java menyediakan perpustakaan multi-threading yang kaya untuk membantu pembangun mencapai pengaturcaraan serentak yang cekap. Artikel ini akan memperkenalkan cara melaksanakan pengaturcaraan serentak menggunakan multi-threading dalam Java dan memberikan contoh kod.

1. Dua cara untuk mencipta utas

Di Java, terdapat dua cara untuk mencipta utas: mewarisi kelas Thread dan melaksanakan antara muka Runnable. Kaedah 1: Warisi kelas Thread Untuk mengelakkan masalah ini, kita perlu memastikan penyegerakan dan pengecualian bersama antara rangkaian. Java menyediakan kata kunci yang disegerakkan untuk mencapai penyegerakan dan pengecualian bersama antara benang.

class MyThread extends Thread {
    @Override
    public void run() {
        System.out.println("MyThread is running");
    }
}

public class Main {
    public static void main(String[] args) {
        MyThread myThread = new MyThread();
        myThread.start();
    }
}

Dalam kod di atas, kami mencipta Kaunter kelas kaunter selamat benang, menggunakan kata kunci yang disegerakkan untuk memastikan operasi atom kaedah kenaikan() dan getCount(). Dalam kaedah main(), kami mencipta dua utas untuk menambah nilai pembilang dan akhirnya mengeluarkan nilai pembilang.

Berbilang utas mungkin perlu berkomunikasi Java menyediakan kaedah seperti tunggu(), notify() dan notifyAll() untuk mencapai komunikasi antara utas.

class MyRunnable implements Runnable {
    @Override
    public void run() {
        System.out.println("MyRunnable is running");
    }
}

public class Main {
    public static void main(String[] args) {
        MyRunnable myRunnable = new MyRunnable();
        Thread thread = new Thread(myRunnable);
        thread.start();
    }
}

Dalam kod di atas, kami mencipta kelas Mesej untuk menyimpan mesej. Kaedah read() menunggu apabila mesej kosong dan tidak kembali sehingga mesej baharu ditulis. Kaedah write() menunggu apabila mesej tidak kosong dan terus menulis mesej baharu sehingga mesej dibaca.

Dalam aplikasi sebenar, mencipta dan memusnahkan benang ialah operasi yang sangat intensif sumber, tetapi kumpulan benang boleh menggunakan semula benang dan mengawal bilangan benang, meningkatkan penggunaan sumber. Java menyediakan kelas ThreadPoolExecutor untuk melaksanakan kumpulan benang.

class Counter {
    private int count = 0;

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

    public synchronized int getCount() {
        return count;
    }
}

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

        Thread thread1 = new Thread(() -> {
            for (int i = 0; i < 1000000; i++) {
                counter.increment();
            }
        });

        Thread thread2 = new Thread(() -> {
            for (int i = 0; i < 1000000; i++) {
                counter.increment();
            }
        });

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

        thread1.join();
        thread2.join();

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

Dalam kod di atas, kami mencipta kumpulan benang yang mengandungi 5 utas dan menyerahkan 10 tugasan kepada kumpulan benang untuk dilaksanakan. Akhir sekali, kita perlu memanggil kaedah executor.shutdown() untuk menutup kumpulan benang.

Ringkasan:

Artikel ini memperkenalkan cara menggunakan multi-threading dalam Java untuk melaksanakan pengaturcaraan serentak dan menyediakan contoh kod yang sepadan. Dengan menggunakan berbilang utas dan melaksanakan penyegerakan, pengecualian bersama dan komunikasi antara utas, kami boleh mencapai pengaturcaraan serentak yang cekap. Pada masa yang sama, menggunakan kumpulan benang juga boleh meningkatkan penggunaan sumber dan prestasi program. Saya harap artikel ini membantu anda memahami pengaturcaraan serentak.

Atas ialah kandungan terperinci Bagaimana untuk melaksanakan pengaturcaraan serentak menggunakan multithreading di Java?. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!