Pelajari secara mendalam prinsip dan teknik pengaturcaraan multithreading Java

Memahami konsep asas dan kemahiran pengaturcaraan Java multi-threading

Dalam dunia pengaturcaraan berorientasikan objek, bahasa Java telah menjadi pilihan popular kerana ciri kestabilan dan merentas platformnya. Pengaturcaraan berbilang benang telah menjadi salah satu cara penting untuk meningkatkan prestasi aplikasi Java. Memahami konsep asas dan kemahiran pengaturcaraan Java multithreading akan membantu pembangun menggunakan teknologi multithreading dengan lebih baik untuk meningkatkan prestasi serentak aplikasi.

1. Konsep asas multi-threading
   Multi-threading merujuk kepada pelaksanaan serentak beberapa thread dalam program Setiap thread boleh melaksanakan tugas yang berbeza, dengan itu mencapai pemprosesan selari. Java menggunakan kelas Thread dan antara muka Runnable untuk melaksanakan multi-threading.

Kelas Thread ialah kelas teras dalam Java yang boleh diwarisi untuk mencipta benang. Subkelas yang mewarisi kelas Thread perlu mengatasi kaedah run dan mentakrifkan tugas yang perlu dilakukan oleh thread dalam kaedah ini. Selepas mencipta objek benang, anda boleh memulakan benang dengan memanggil kaedah mula.

Antaramuka Runnable ialah antara muka berfungsi yang mentakrifkan tugas yang boleh dilaksanakan oleh benang. Kelas yang melaksanakan antara muka Runnable perlu melaksanakan kaedah run dan menentukan tugasan yang perlu dilakukan oleh thread dalam kaedah ini. Tidak seperti mewarisi kelas Thread, melaksanakan antara muka Runnable boleh menjadikan kelas lebih fleksibel kerana Java tidak menyokong warisan berbilang.

2. Kemahiran pengaturcaraan berbilang benang
   2.1 Penyegerakan dan pengecualian bersama
   Dalam pengaturcaraan berbilang benang, jika berbilang rangkaian mengakses sumber dikongsi pada masa yang sama, ketidakkonsistenan atau pengecualian data mungkin berlaku. Untuk menyelesaikan masalah ini, anda boleh menggunakan kata kunci yang disegerakkan untuk mencapai penyegerakan. Kata kunci yang disegerakkan boleh mengubah suai kaedah atau blok kod untuk memastikan hanya satu utas boleh melaksanakan kod yang diubah suai dengan disegerakkan pada masa yang sama.

Contoh kod:

public class Counter {
    private int count;

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

2.2 Komunikasi benang
Komunikasi benang membolehkan benang bekerjasama antara satu sama lain dan menyelesaikan tugasan bersama-sama. Java menyediakan tiga kaedah: tunggu, maklumkan dan notifyAll untuk melaksanakan komunikasi antara utas. Antaranya, kaedah tunggu meletakkan utas ke dalam keadaan menunggu sehingga ia dibangkitkan oleh utas lain yang memanggil kaedah notify atau notifyAll;

Kod sampel:

public class MessageQueue {
    private String message;
    private boolean hasMessage;

    public synchronized void putMessage(String message) {
        while (hasMessage) {
            try {
                wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        this.message = message;
        hasMessage = true;
        notifyAll();
    }

    public synchronized String getMessage() {
        while (!hasMessage) {
            try {
                wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        String msg = message;
        hasMessage = false;
        notifyAll();
        return msg;
    }
}

2.3 Kumpulan benang
Mencipta benang adalah mahal, dan pengurusan bilangan benang yang tidak betul boleh menyebabkan sumber sistem kehabisan. Gunakan kumpulan utas untuk mengurus bilangan utas, guna semula utas yang dibuat dan mengawal susunan pelaksanaan dan keutamaan utas. Java menyediakan antara muka Executor dan ExecutorService dan kelas pelaksanaan ThreadPoolExecutor untuk melaksanakan kumpulan benang.

Kod contoh:

public class ThreadPoolExample {
    public static void main(String[] args) {
        ExecutorService executor = Executors.newFixedThreadPool(10);
        for (int i = 0; i < 100; i++) {
            final int taskIndex = i;
            executor.execute(new Runnable() {
                @Override
                public void run() {
                    System.out.println("执行任务：" + taskIndex);
                }
            });
        }
        executor.shutdown();
    }
}

Melalui pengenalan di atas, anda dapat melihat bahawa pengaturcaraan berbilang benang Java melibatkan teknologi seperti penyegerakan dan pengecualian bersama, komunikasi benang dan kumpulan benang. Memahami konsep asas dan teknik pengaturcaraan ini boleh membantu pembangun menggunakan teknologi berbilang benang dengan lebih baik untuk meningkatkan prestasi serentak aplikasi Java.

Atas ialah kandungan terperinci Pelajari secara mendalam prinsip dan teknik pengaturcaraan multithreading Java. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!