Pengaturcaraan Berbilang Thread dalam Java

Pengaturcaraan berbilang benang dalam Java

Java ialah bahasa pengaturcaraan yang digunakan secara meluas dalam bidang pembangunan perisian, dan pengaturcaraan berbilang benang ialah corak pengaturcaraan biasa di Java. Pengaturcaraan berbilang benang boleh membolehkan program melaksanakan berbilang tugas pada masa yang sama, meningkatkan keselarasan dan kecekapan program. Artikel ini akan memperkenalkan anda kepada pengaturcaraan berbilang benang di Java.

Konsep asas multi-threading

Multi-threading merujuk kepada keupayaan program untuk melaksanakan pelbagai tugas pada masa yang sama. Dalam kes CPU teras tunggal, multithreading dicapai oleh CPU bertukar dengan cepat antara tugas yang berbeza. Dalam kes CPU berbilang teras, berbilang tugas boleh dilaksanakan serentak pada teras CPU yang berbeza.

Pelaksanaan berbilang benang di Jawa

Berbilang benang di Jawa dilaksanakan dengan mencipta objek kelas Benang, yang menyediakan pelaksanaan benang ringan. Thread boleh dibuat dengan mewarisi kelas Thread atau melaksanakan antara muka Runnable.

1. Warisi kelas Thread

Mewarisi kelas Thread ialah cara paling mudah untuk melaksanakannya Anda hanya perlu mencipta kelas dan mewarisi kelas Thread, dan mengatasinya kaedah run() untuk mencapai keupayaan multi-threading. Seperti yang ditunjukkan di bawah:

public class MyThread extends Thread {

    @Override
    public void run() {
        // 运行多线程的函数代码
    }
}

Cipta objek MyThread dan panggil kaedah start() untuk memulakan urutan baharu:

MyThread thread = new MyThread();
thread.start();

2. Laksanakan antara muka Runnable

Melaksanakan antara muka Runnable juga merupakan cara untuk melaksanakan multi-threading. Ia perlu melaksanakan kaedah run(), tetapi perlu menghantar contoh antara muka Runnable kepada pembina kelas Thread. Seperti yang ditunjukkan di bawah:

public class MyRunnable implements Runnable {

    @Override
    public void run() {
        // 运行多线程函数代码
    }
}

Buat dan mulakan utas MyRunnable:

MyRunnable runnable = new MyRunnable();
Thread thread = new Thread(runnable);
thread.start();

Kelas Thread dalam Java menyediakan beberapa kaedah dan sifat lain untuk memantau dan mengawal status dan tingkah laku utas, Untuk contoh, kaedah seperti join(), yield(), sleep(), setPriority() dan isAlive().

Penyegerakan berbilang benang

Dalam pengaturcaraan berbilang benang, berbilang benang boleh mengakses sumber yang sama. Pada masa ini, adalah perlu untuk memastikan penyegerakan benang dan pengecualian bersama untuk menghalang berbilang benang daripada mengubah suai sumber yang sama pada masa yang sama, menyebabkan kekeliruan atau ralat data. Java menyediakan pelbagai kaedah penyegerakan:

1. Blok kod disegerakkan

Dengan kata kunci yang disegerakkan, anda boleh menandakan kaedah atau blok kod sebagai disegerakkan, supaya hanya satu entri Benang blok boleh melaksanakan kod di dalamnya. Seperti yang ditunjukkan di bawah:

public class SynchronizedThread {
    // 定义一个计数器
    private int count = 0;

    // 定义同步的方法
    public synchronized void addCount() {
        count++;
        System.out.println("count = " + count);
    }

    // 定义一个线程类来调用 addCount() 方法
    private static class MyThread extends Thread {
        private SynchronizedThread synchronizedThread;

        public MyThread(SynchronizedThread synchronizedThread) {
            this.synchronizedThread = synchronizedThread;
        }

        @Override
        public void run() {
            for (int i = 0; i < 10; i++) {
                synchronizedThread.addCount();
            }
        }
    }

    public static void main(String[] args) {
        SynchronizedThread synchronizedThread = new SynchronizedThread();
        MyThread thread1 = new MyThread(synchronizedThread);
        MyThread thread2 = new MyThread(synchronizedThread);
        thread1.start();
        thread2.start();
    }
}

2. Kaedah disegerakkan

Selepas menandakan kaedah sebagai disegerakkan, kaedah itu akan disegerakkan dan hanya satu utas boleh memasukinya. Contohnya:

public synchronized void addCount() {
    count++;
    System.out.println("count = " + count);
}

3. Kelas kunci

Kunci ialah satu lagi mekanisme penyegerakan dalam Java. Ia menyediakan penyegerakan benang yang lebih fleksibel, menjadikannya lebih mudah untuk bertukar antara berbilang kunci. Lock melaksanakan antara muka java.util.concurrent.locks.Lock dan menyediakan kaedah berikut:

• lock(): Cuba dapatkan kunci jika kunci sudah diisi, benang akan Tunggu sehingga kunci diperolehi.
• buka kunci(): Lepaskan kunci.
• tryLock(): Cuba dapatkan kunci Jika kunci sudah diisi, ia akan kembali palsu dengan serta-merta.
• newCondition(): Mengembalikan contoh Keadaan yang berkaitan dengan kunci ini Sebelum memanggil kaedah await() Keadaan, benang mesti mendapatkan kunci monitor objek yang dikaitkan dengan kunci.

Contohnya:

Lock lock = new ReentrantLock();

public void addCount() {
    lock.lock();
    try {
        count++;
        System.out.println("count = " + count);
    } finally {
        lock.unlock();
    }
}

Java Thread Pool

Thread pool di Java ialah mekanisme untuk mengurus dan menggunakan semula thread. Kumpulan benang boleh menggunakan prestasi CPU dengan lebih baik, mengurangkan penciptaan dan pemusnahan benang, dan meningkatkan kelajuan tindak balas program. Di Jawa, kumpulan benang boleh dibuat melalui kelas ThreadPoolExecutor. Anda boleh menentukan parameter seperti saiz kumpulan benang dan panjang baris gilir, dan anda juga boleh melakukan pelbagai tugas.

Contohnya:

ExecutorService threadPool = Executors.newFixedThreadPool(10);
threadPool.execute(new Runnable() {
    @Override
    public void run() {
        // 执行任务
    }
});

Ringkasan

Pengaturcaraan berbilang benang Java ialah cara penting untuk meningkatkan keselarasan dan kecekapan program. Selain memperkenalkan dua cara untuk mencipta berbilang benang dalam Java (mewarisi kelas Thread dan melaksanakan antara muka Runnable), ia juga memperkenalkan pelbagai kaedah penyegerakan dan kumpulan benang Java. Memahami konsep asas dan kaedah pelaksanaan pengaturcaraan berbilang benang adalah penting untuk membangunkan program yang cekap dan serentak.

Atas ialah kandungan terperinci Pengaturcaraan Berbilang Thread dalam Java. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!