Amalan dan pertimbangan terbaik untuk pengaturcaraan selari di Java

Dalam pengaturcaraan selari Java, adalah penting untuk mengikuti amalan terbaik, termasuk menggunakan objek tidak boleh ubah, menyegerakkan akses serentak, mengelakkan kebuntuan, mengendalikan pengecualian dengan betul dan menggunakan perpustakaan serentak. Selain itu, disegerakkan mesti digunakan dengan berhati-hati, mengelakkan menunggu sibuk dan mengenal pasti isu keterlihatan perkongsian. Dengan mengikuti prinsip ini, anda boleh memanfaatkan sepenuhnya pengaturcaraan selari sambil mengelakkan perangkap dan meningkatkan prestasi aplikasi. . Bahasa Java membolehkan pembangun membuat program serentak dengan mudah dengan menyediakan API selari yang kaya.

Walau bagaimanapun, pengaturcaraan selari juga membawa beberapa cabaran, seperti keselamatan benang, kebuntuan dan keadaan perlumbaan. Untuk memanfaatkan sepenuhnya pengaturcaraan selari sambil mengelakkan perangkap ini, adalah penting untuk mengikuti amalan dan pertimbangan terbaik.

Amalan Terbaik

1. Gunakan objek tidak boleh ubah

Dalam persekitaran serentak, keadaan yang dikongsi boleh membawa kepada isu keselamatan benang. Dengan menggunakan objek tidak berubah, keadaan ini boleh dihapuskan kerana keadaan objek tidak berubah tidak boleh diubah setelah ia dicipta.

2. Akses serentak disegerakkan

Apabila berbilang rangkaian mengakses data kongsi pada masa yang sama, adalah sangat penting untuk menggunakan mekanisme penyegerakan. Java menyediakan pelbagai mekanisme penyegerakan, seperti kunci (kata kunci disegerakkan) dan semaphore (kelas Semaphore).

3. Elakkan kebuntuan

Kebuntuan merujuk kepada situasi di mana dua atau lebih utas sedang menunggu antara satu sama lain untuk melepaskan kunci, menyebabkan semua utas tidak dapat diteruskan. Cara terbaik untuk mengelakkan kebuntuan adalah dengan mengikuti garis panduan pesanan kunci, iaitu sentiasa memperoleh kunci dalam susunan yang sama.

4. Mengendalikan pengecualian dengan betul

Dalam program serentak, pengendalian pengecualian perlu berhati-hati. Menggunakan pernyataan cuba-dengan-sumber boleh memastikan bahawa sumber dikeluarkan secara automatik apabila pengecualian berlaku dan mengelakkan kebocoran sumber.

5. Gunakan perpustakaan concurrency

Java menyediakan banyak perpustakaan concurrency, seperti ConcurrentHashMap, ConcurrentLinkedQueue dan ExecutorService. Perpustakaan ini menyediakan kelas koleksi selamat benang yang memudahkan pengaturcaraan serentak.

Nota

1 Penggunaan disegerakkan dengan berhati-hati

Walaupun disegerakkan adalah mekanisme penyegerakan yang berguna, penggunaan yang berlebihan akan mengurangkan prestasi program. Gunakannya hanya apabila anda memerlukan akses segerak kepada data yang dikongsi.

2. Elakkan sibuk menunggu

Sibuk menunggu bermakna thread berulang kali meninjau pembolehubah keadaan sehingga ia benar. Ini membazir sumber CPU, jadi mekanisme tunggu/beritahu (kaedah wait() dan notify()) harus digunakan.

3. Kenal pasti isu keterlihatan dikongsi

Disebabkan model memori Java, keterlihatan antara pembolehubah yang dikongsi mungkin tertunda. Keterlihatan pembolehubah yang dikongsi boleh dipastikan menggunakan kata kunci yang tidak menentu atau halangan memori.

Kes praktikal

Pertimbangkan program mudah di mana berbilang benang perlu mengira jumlah set nombor secara selari:

import java.util.concurrent.*;

class SumCalculator implements Callable<Long> {
    private long[] numbers;
    private int start;
    private int end;

    public SumCalculator(long[] numbers, int start, int end) {
        this.numbers = numbers;
        this.start = start;
        this.end = end;
    }

    @Override
    public Long call() {
        long sum = 0;
        for (int i = start; i < end; i++) {
            sum += numbers[i];
        }
        return sum;
    }
}

public class ConcurrentSumCalculator {

    public static long calculateSum(long[] numbers) throws InterruptedException, ExecutionException {
        int numThreads = Runtime.getRuntime().availableProcessors();
        ExecutorService executor = Executors.newFixedThreadPool(numThreads);
        
        // 将数组分成多个部分，并为每部分创建计算任务
        int chunkSize = numbers.length / numThreads;
        List<Future<Long>> futures = new ArrayList<>();
        for (int i = 0; i < numbers.length; i += chunkSize) {
            int end = Math.min(i + chunkSize, numbers.length);
            futures.add(executor.submit(new SumCalculator(numbers, i, end)));
        }
        
        // 收集各个部分的计算结果
        long totalSum = 0;
        for (Future<Long> future : futures) {
            totalSum += future.get();
        }
        
        // 关闭线程池
        executor.shutdown();
        
        return totalSum;
    }

    public static void main(String[] args) throws InterruptedException, ExecutionException {
        long[] numbers = new long[1000000];
        for (int i = 0; i < numbers.length; i++) {
            numbers[i] = i;
        }

        long sum = calculateSum(numbers);
        System.out.println("Sum: " + sum);
    }
}

Dalam contoh ini, kami menggunakan ThreadPool untuk mencipta tugas pengiraan serentak yang mengira set nombor secara selari Jumlah. Ambil perhatian bahawa kami menggunakan objek Masa Depan untuk mengumpul hasil pengiraan setiap tugas untuk memastikan keselamatan benang.

Atas ialah kandungan terperinci Amalan dan pertimbangan terbaik untuk pengaturcaraan selari di Java. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!