Coffee break #94. Semakan lima penganalisis kod Java statik. Ralat memori timbunan dan tindanan Java

Semakan lima penganalisis kod Java statik

Sumber: Pembangun DZone sering memerlukan pelbagai program, termasuk penganalisis kod statik, yang boleh mencari dan membetulkan kod yang salah pada awal pembangunan. Walaupun semakan kod adalah alat yang tidak ternilai dalam usaha ini, kadangkala jumlah penyemak kod perlu menyemak dan menyemak adalah menakutkan. Ini memerlukan banyak masa dan usaha. Ini juga membawa kepada fakta bahawa penyemak sering hanya memberi perhatian kepada serpihan kod yang penting untuk pengendalian program. Manakala alat analisis statik menyemak semua kod dengan ketepatan yang sama. Saya telah mengumpulkan beberapa penganalisis kod yang serasi dengan IntelliJ IDEA. Saya harap ini membantu anda dalam kerja anda.

Penganalisis IntelliJ IDEA terbina dalam

Penganalisis kod Java statik yang dibina ke dalam IntelliJ IDEA sama sekali tidak kalah dengan alat analisis statik khusus. Pencarian serpihan kod yang mencurigakan, berselerak atau tidak betul dijalankan menggunakan pelbagai kaedah analisis statik: analisis aliran data dan padanan corak. IntelliJ IDEA mempunyai sejumlah besar pemeriksaan. Sebenarnya, ramai daripada mereka tidak selalu melaporkan ralat dengan tepat. Sebaliknya, mereka menunjukkan kecerobohan dalam kod atau kemungkinan menukarnya dengan alternatif yang kemas. Selepas mengkaji "Pemeriksaan → Java" sedikit, saya perhatikan satu perkara. Pemeriksaan dalam kategori ralat berkemungkinan, masalah berangka dan masalah bersiri berkemungkinan besar menemui ralat sebenar. Walau apa pun, anda mesti menjalankan ujian sendiri dan menentukan yang mana yang akan berguna untuk projek anda. Oleh kerana analisis statik dilakukan dalam mod penyuntingan kod, dalam IntelliJ IDEA anda boleh membetulkan ralat dalam beberapa saat selepas ralat itu berlaku. Editor segera menyerlahkan serpihan kod yang salah. Ia sangat mudah dan sejuk! Di samping itu, jika anda menggunakan gabungan "Alt + Enter" pada sekeping kod yang dipilih, anda boleh memilih salah satu pilihan untuk membetulkan ralat melalui menu konteks: Anda juga boleh mengetahui sebab menjalankan pemeriksaan tertentu . Dalam sesetengah kes, ini mengurangkan masa carian: Anda boleh menjalankan analisis secara manual dengan memilih "Analisis → Semak Kod". Atau anda boleh menjalankan semakan individu menggunakan "Analisis → Jalankan semakan mengikut nama". Sebelum melakukan ini, nyatakan skop analisis (untuk projek, modul atau fail individu). Apabila anda menjalankan analisis dengan cara ini, beberapa pemeriksaan tersedia yang tidak berfungsi dalam mod edit kerana kerumitan. Selepas analisis, keputusan akan dikumpulkan mengikut kategori/direktori dalam tetingkap berasingan. Dari tetingkap ini anda boleh menavigasi ke pencetus pengesahan tertentu: IntelliJ hanya membenarkan anda menyimpan hasil analisis dalam format HTML dan XML. Malangnya, pada pendapat saya, adalah paling mudah untuk menangani masalah yang dikesan dalam IDE itu sendiri. Catatan. Kebanyakan ciri penganalisis statik tersedia dalam Edisi Komuniti IntelliJ IDEA percuma.

SonarJava

SonarJava ialah penganalisis kod statik untuk Java daripada SonarSource. Senarai fungsinya termasuk:

• 150+ peraturan pengesanan ralat;
• 350+ peraturan untuk mengenali bau kod;
• 40+ peraturan untuk mengesan potensi kelemahan ;
• Integrasi dengan Maven, Gradle, Ant, Eclipse, IntelliJ IDEA, VS Code;
• Boleh dikembangkan dengan peraturan diagnostik tersuai;
• Alat SAST khusus: kebanyakan peraturan diagnostik disusun mengikut CWE , CERT , OWASP .

Anda boleh menjalankan analisis kedua-duanya dalam pelbagai IDE (melalui pemalam SonarLint ) dan secara berasingan dalam SonarQube . SonarLint boleh berfungsi bersebelahan dengan penganalisis kod IntelliJ IDEA terbina dalam. Jika anda menuding pada sekeping kod yang diserlahkan, anda selalunya boleh melihat amaran daripada kedua-dua penganalisis: Sudah tentu, anda boleh melihat amaran dalam tetingkap berasingan: Secara keseluruhannya, keupayaan untuk menjalankan SonarJava dalam cara yang berbeza menjadikannya menarik. Ini memberi pembangun kebebasan untuk memilih alat semasa menulis kod.

FindBugs/SpotBugs

Malangnya, FindBugs tidak dikemas kini untuk masa yang lama; keluaran stabil terakhir dikeluarkan pada tahun 2015. Tetapi kami masih ingat dan menggunakannya, kerana ia mungkin penganalisis kod Java statik percuma yang paling terkenal. Jika anda bertanya kepada pembangun Java tentang analisis statik, mereka mungkin akan segera memikirkan FindBugs. Penganalisis sumber terbuka SpotBugs menjadi kesinambungan logik dari FindBugs yang ditinggalkan. Ia mempunyai semua kelebihan dan kekurangan FindBugs. Masa akan menentukan sama ada ini baik atau buruk. Dalam pada itu, komuniti penganalisis sedang giat membangunkannya. Ciri utama SpotBugs:

• 400+ peraturan pengesanan ralat;
• Integrasi ke dalam Ant, Maven, Gradle, Eclipse, IntelliJ IDEA;
• Boleh dikembangkan dengan peraturan diagnostik tersuai.

Untuk mencari kod yang mencurigakan, metodologi yang sama digunakan: padanan corak dan analisis aliran data. Penganalisis mengesan pelbagai jenis ralat yang berkaitan dengan multithreading, prestasi, kelemahan, kekeliruan kod dan sebagainya. Dalam IntelliJ IDEA, tetingkap amaran kelihatan seperti ini: Makluman boleh dikumpulkan mengikut kategori, kelas, direktori dan tahap keyakinan. Anda boleh melihat makluman dan dokumentasi secara serentak untuk sebarang peraturan diagnostik. Analisis dimulakan secara manual. Selepas analisis, semua serpihan kod bermasalah diserlahkan bersama amaran lain daripada IntelliJ IDEA dan SonarLint. Walau bagaimanapun, terdapat masalah. Anda mesti menjalankan semula analisis untuk mengemas kini amaran untuk mencerminkan perubahan yang anda buat pada fail. Terdapat juga banyak amaran nasihat, jadi penganalisis mesti dikonfigurasikan sebelum digunakan secara aktif.

PVS-Studio

PVS-Studio adalah berdasarkan pustaka sumber terbuka Spoon. Ia mengambil kod sumber sebagai input dan membina model AST yang direka dengan baik dengan maklumat semantik. Berdasarkan model ini, penganalisis menggunakan teknik moden seperti:

• Analisis aliran data;
• Prestasi simbolik;
• Anotasi kaedah;
• Analisis berasaskan corak.

Pada masa ini, penganalisis menggunakan lebih daripada 105 peraturan diagnostik yang mengenal pasti pelbagai kelemahan kod. Ini termasuk pembetulan kesilapan menaip, menamakan semula rujukan nol, kod tidak boleh dicapai, indeks tatasusunan di luar sempadan, pelanggaran penggunaan kontrak kaedah dan ralat lain. Anda boleh mengetahui semua keupayaan peraturan diagnostik di sini . Fungsi utama PVS-Studio:

• Penganalisis memberi tumpuan kepada mencari ralat sebenar;
• Sebagai tambahan kepada versi CLI, terdapat juga penyepaduan dengan IntelliJ IDEA, Maven, Gradle, Jenkins, SonarQube;
• Keupayaan untuk menjalankan penganalisis dalam mod tambahan;
• Penganalisis mengenal pasti isu keserasian yang berpotensi dengan API Java SE apabila memindahkan projek daripada Java 8 kepada versi yang lebih terkini;
• PVS-Studio menukar laporan kepada pelbagai format mesra pengguna: JSON, XML, HTML, TXT;
• Alat SAST khusus: kebanyakan peraturan diagnostik disusun mengikut CWE , CERT , OWASP .

PMD

PMD ialah penganalisis statik sumber terbuka. Ia mengenal pasti ralat pembangunan biasa: pembolehubah yang tidak digunakan, blok kosong, penciptaan objek yang tidak perlu dan masalah lain. Penganalisis menggunakan kod sumber sebagai input. Pada masa ini, PMD menganalisis satu fail sumber bagi setiap proses, yang mengenakan had ke atas kesempurnaan analisis. Pengarang PMD menasihatkan memasang projek sebelum analisis. Ini membolehkan anda mengekstrak maklumat tentang jenis yang digunakan dalam kod yang dianalisis. Fungsi utama PMD:

• Integrasi dengan pelbagai IDE (IntelliJ IDEA, Eclipse, NetBeans) dan membina sistem (Maven, Gradle, Ant);
• Menyokong pelbagai format laporan penganalisis: SARIF, CSV, IDEA, JSON, teks (lalai), XML, HTML, TextColor dan sebagainya;
• Mempunyai lebih daripada 300 templat peraturan diagnostik. Kategori: gaya pengekodan, amalan terbaik, pepijat, multithreading, prestasi dan sebagainya;
• Menyediakan CPD (Copy-Paste Detector) bersama-sama dengan PMD yang mengesan pendua dalam kod.

Jika kita melihat semua peraturan diagnostik, PMD lebih tertumpu pada menyelesaikan masalah gaya pengekodan dan menangkap ralat yang jelas. Peraturan diagnostik mungkin bercanggah antara satu sama lain, jadi ia mesti dikonfigurasikan sebelum menggunakan penganalisis. Anda juga boleh menjalankan analisis melalui pemalam untuk IntelliJ IDEA, tetapi anda tidak boleh memilih fail individu untuk analisis. Tetingkap amaran kelihatan seperti ini: Pada pendapat saya, bekerja dengan amaran tidak begitu mudah, kerana ia tidak boleh dikumpulkan mengikut fail dan mesej yang tidak jelas. Ia hanya muncul apabila anda menuding pada amaran.

Kesimpulan

Sudah tentu, sebagai tambahan kepada penganalisis yang dibincangkan di atas, terdapat penyelesaian lain. Terdapat kedua-dua program berbayar (Coverity, Klockwork, JArchitect) dan percuma (Error Prone, Infer, Checkstyle). Mereka semua menumpukan pada satu perkara: menghalang kod yang salah atau berkemungkinan buggy daripada mencapai pengeluaran. Saya tidak mempunyai hak untuk menilai penganalisis mana yang lebih sesuai untuk tugas ini. Tetapi penganalisis yang membangunkan analisis aliran data dan pelaksanaan simbolik lebih berkemungkinan mencari pepijat sebenar dalam kod tersebut. Jika anda memilih penganalisis statik, beri perhatian kepada:

• penyepaduan ke dalam pelbagai IDE;
• penyepaduan ke dalam sistem pemasangan;
• kemudahan melancarkan penganalisis pada pelayan;
• keupayaan untuk mengesan ralat dalam mod penyuntingan kod;
• keupayaan untuk bekerja dengan mudah dengan amaran;
• Orientasi SAST;
• peratusan positif palsu;
• kerumitan konfigurasi.
• Gabungan semua kebaikan dan keburukan akan membawa anda kepada bilangan penganalisis statik yang anda anggap sebagai yang terbaik.

Nota: Saya memberikan contoh dengan penyepaduan ke dalam IntelliJ IDEA, kerana saya sering menggunakannya.

Ralat memori timbunan dan tindanan Java

Sumber: DZone Sekarang kita akan melihat ralat utama yang boleh berlaku dalam ingatan timbunan atau timbunan Java, tetapi mari kita ingat dahulu maksud kedua-dua istilah ini.

• Heap memory adalah kawasan khas memori di mana objek java disimpan.
• Memori tindanan ialah kawasan memori sementara untuk menyimpan pembolehubah apabila memanggil kaedah.

Pengecualian utama yang menerangkan masalah ingatan timbunan ialah java.lang.OutOfMemoryError .

Ruang Timbunan Java

Ralat ini berlaku apabila program Java gagal memperuntukkan objek baharu dalam kawasan ingatan timbunan.

Had Overhed GC Melebihi

Program Java menghabiskan terlalu banyak masa melakukan pengumpulan sampah. Ralat ini muncul apabila kutipan sampah mengambil 98% daripada masa program dan memulihkan kurang daripada 2% ruang memori.

public class OutOfMemoryErrorDemo {
    public static void main(String[] args) {
        int i = 0;
        List<String> stringList = new ArrayList<>();
        while (i < Integer.MAX_VALUE) {
            i++;
            String generatedString = new String( "Some string generated to show out of memory error example " + i);
            stringList.add(generatedString);
        }
    }
}

Di sini stringList mengandungi rujukan kepada rentetan terjana kami, jadi pengumpul sampah tidak boleh mengalih keluar rentetan yang dijana daripada memori, tetapi cuba mengalih keluar sebarang sampah lain dalam aplikasi. Tetapi ini tidak mencukupi.

Saiz Tatasusunan yang Diminta Melebihi Had VM

Ralat berlaku apabila anda cuba memperuntukkan tatasusunan apabila tidak cukup ruang dalam timbunan.

public class OutOfMemoryErrorDemo {
    public static void main(String[] args) {
        // we try to create too long array
        long[] array = new long[Integer.MAX_VALUE];
    }
}

Metaspace

Pengecualian dilemparkan dengan mesej ini apabila tiada ruang di rantau metaspace untuk maklumat data kelas.

Tiada ruang swap (Minta Bait Saiz Atas Sebab. Kehabisan Ruang Tukar?)

Ralat muncul apabila memori tidak dapat diperuntukkan pada timbunan asli atau saiznya tidak mencukupi.

sebab tindanan_jejak_dengan_kaedah_asli

Antara muka Java asli atau kaedah asli gagal memperuntukkan memori pada timbunan. StackOverFlowError - apabila terdapat terlalu banyak panggilan kaedah. Biasanya pengecualian dilemparkan oleh kaedah yang mempunyai rekursi di dalamnya.

public class StackOverFlowErrorDemo {

    public static void main(String[] args) {
        recursiveMethod(2);
    }

    public static int recursiveMethod(int i) {
      	// it will never stop and it allocates all stack memory
        return recursiveMethod(i);
    }
}