Panduan Praktikal untuk Model Pengaturcaraan Konkurensi Teras JAVA

Panduan Praktikal Model Pengaturcaraan Konkurensi Teras JAVA

Dalam bidang pembangunan perisian hari ini, pemproses berbilang teras dan sistem teragih telah menjadi arus perdana. Untuk menggunakan sepenuhnya sumber perkakasan, kita perlu menulis program serentak untuk mencapai pemprosesan selari dan meningkatkan prestasi. Sebagai bahasa pengaturcaraan arus perdana, JAVA menyediakan set yang kaya dengan model dan alatan pengaturcaraan serentak. Artikel ini akan membawa anda kepada pemahaman yang mendalam tentang model pengaturcaraan serentak teras JAVA melalui beberapa contoh kod khusus dan mempelajari cara menggunakan model ini untuk mempraktikkan pengaturcaraan serentak.

1. Asas Threading
   Pertama sekali, mari kita lihat elemen pengaturcaraan serentak yang paling asas dalam JAVA: benang. Benang dalam JAVA diwakili oleh kelas java.lang.Thread. Berikut ialah contoh urutan mudah:

public class MyThread extends Thread {
    @Override
    public void run() {
        System.out.println("Hello, this is my thread!");
    }

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

Dalam contoh ini, kami mencipta kelas urutan tersuai MyThread yang mewarisi daripada Thread, dan mengatasi kaedah larian Dalam kaedah larian Keluarkan yang mudah mesej. Dalam kaedah utama, kami mencipta contoh MyThread dan memulakan utas melalui kaedah mula.

2. Antaramuka boleh dijalankan
   Selain mewarisi kelas Thread, kami juga boleh melaksanakan antara muka java.lang.Runnable untuk mencipta benang. Berikut ialah contoh menggunakan antara muka Runnable:

public class MyRunnable implements Runnable {
    @Override
    public void run() {
        System.out.println("Hello, this is my runnable!");
    }

    public static void main(String[] args) {
        Thread myThread = new Thread(new MyRunnable());
        myThread.start();
    }
}

Dalam contoh ini, kami mencipta kelas tersuai MyRunnable yang melaksanakan antara muka Runnable dan mengatasi kaedah run. Dalam kaedah utama, kami mencipta objek Thread, menghantar contoh MyRunnable sebagai parameter, dan memulakan utas melalui kaedah mula.

3. Thread Pool
   Dalam pengaturcaraan serentak sebenar, penciptaan dan pemusnahan benang yang kerap akan menyebabkan overhed prestasi yang besar. Oleh itu, JAVA menyediakan kumpulan benang untuk mengurus dan menggunakan semula benang. Berikut ialah contoh mudah menggunakan kumpulan benang:

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class ThreadPoolExample {
    public static void main(String[] args) {
        ExecutorService executor = Executors.newFixedThreadPool(3);
        for (int i = 0; i < 5; i++) {
            Runnable worker = new WorkerThread("" + i);
            executor.execute(worker);
        }
        executor.shutdown();
        while (!executor.isTerminated()) {
        }
        System.out.println("Finished all threads");
    }
}

class WorkerThread implements Runnable {
    private String message;

    public WorkerThread(String s) {
        this.message = s;
    }

    public void run() {
        System.out.println(Thread.currentThread().getName() + " (Start) message = " + message);
        processMessage();
        System.out.println(Thread.currentThread().getName() + " (End)");
    }

    private void processMessage() {
        try {
            Thread.sleep(2000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

Dalam contoh ini, kami menggunakan kelas alat Pelaksana untuk mencipta kumpulan benang dengan saiz tetap 3. Kemudian, kami mencipta 5 kejadian WorkerThread dan menyerahkannya ke kumpulan utas Kumpulan utas akan bertanggungjawab untuk mengurus pelaksanaan utas ini.

4. Kunci dan penyegerakan
   Dalam pengaturcaraan serentak, kunci dan penyegerakan adalah konsep yang sangat penting. JAVA menyediakan kata kunci yang disegerakkan dan antara muka Kunci untuk membantu kami mencapai penyegerakan antara utas. Berikut ialah contoh penggunaan kata kunci yang disegerakkan:

public class Counter {
    private int count = 0;

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

    public synchronized void decrement() {
        count--;
    }

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

Dalam contoh ini, kami mencipta kelas Counter, di mana kaedah kenaikan, pengurangan dan getCount semuanya menggunakan kata kunci yang disegerakkan penyegerakan. Ini memastikan bahawa panggilan ke kaedah ini daripada berbilang rangkaian adalah selamat.

Selain itu, pakej konkurensi JAVA juga menyediakan pelbagai pelaksanaan kunci, seperti ReentrantLock dan ReadWriteLock. Berikut ialah contoh penggunaan ReentrantLock:

import java.util.concurrent.locks.ReentrantLock;

public class ReentrantLockExample {
    private final ReentrantLock lock = new ReentrantLock();

    public void performTask() {
        lock.lock();
        try {
            // 执行需要同步的代码块
        } finally {
            lock.unlock();
        }
    }
}

Dalam contoh ini, kami mencipta tika ReentrantLock dan menggunakan kunci dan buka kunci untuk mengunci dan membuka kunci bahagian kritikal. Kaedah ini lebih fleksibel daripada kata kunci yang disegerakkan dan boleh mengawal pemerolehan dan pelepasan kunci secara manual.

5. Concurrent Collection
   Untuk berkongsi data dengan selamat dalam pengaturcaraan serentak, JAVA menyediakan beberapa kelas pengumpulan selamat serentak, seperti ConcurrentHashMap dan CopyOnWriteArrayList. Berikut ialah contoh penggunaan ConcurrentHashMap:

import java.util.concurrent.ConcurrentHashMap;

public class ConcurrentMapExample {
    private ConcurrentHashMap<String, String> map = new ConcurrentHashMap<>();

    public void addKeyValuePair(String key, String value) {
        map.put(key, value);
    }

    public String getValueByKey(String key) {
        return map.get(key);
    }
}

Dalam contoh ini, kami mencipta contoh ConcurrentHashMap dan menggunakan kaedah put dan get untuk memanipulasi data dalam Peta tanpa operasi penyegerakan tambahan.

Melalui contoh di atas, kami mempunyai pemahaman yang mendalam tentang model pengaturcaraan serentak teras JAVA, termasuk asas benang, kumpulan benang, kunci dan penyegerakan serta koleksi serentak. Dalam projek sebenar, penggunaan munasabah model pengaturcaraan serentak ini boleh meningkatkan prestasi dan kestabilan program. Saya harap artikel ini dapat membantu pembaca menguasai pengetahuan pengaturcaraan serentak dalam JAVA dan menulis program serentak yang cekap secara praktikal.

Atas ialah kandungan terperinci Panduan Praktikal untuk Model Pengaturcaraan Konkurensi Teras JAVA. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!