Coffee break #94. Pagsusuri ng limang static na Java code analyzer. Java heap at stack memory error

Pagsusuri ng limang static na Java code analyzer

Pinagmulan: Ang mga DZone Developer ay madalas na nangangailangan ng iba't ibang mga programa, kabilang ang mga static na code analyzer, na makakahanap at makakapag-ayos ng maling code nang maaga sa pagbuo. Habang ang mga pagsusuri sa code ay isang napakahalagang tool sa pagsisikap na ito, kung minsan ang dami ng mga tagasuri ng code na kailangang suriin at suriin ay nakakatakot. Ito ay nangangailangan ng maraming oras at pagsisikap. Ito rin ay humahantong sa katotohanan na ang mga tagasuri ay madalas na binibigyang pansin lamang ang mga fragment ng code na kritikal para sa pagpapatakbo ng programa. Samantalang ang mga static na tool sa pagsusuri ay sinusuri ang lahat ng code na may parehong katumpakan. Nagsama-sama ako ng ilang code analyzer na tugma sa IntelliJ IDEA. Sana makatulong ito sa iyong trabaho.

Built-in na IntelliJ IDEA analyzer

Ang static na Java code analyzer na binuo sa IntelliJ IDEA ay hindi mas mababa sa mga espesyal na tool sa static na pagsusuri. Ang paghahanap para sa mga kahina-hinala, kalat-kalat o hindi tamang mga fragment ng code ay isinasagawa gamit ang iba't ibang paraan ng static na pagsusuri: pagsusuri ng daloy ng data at pagtutugma ng pattern. Ang IntelliJ IDEA ay may malaking bilang ng mga inspeksyon. Sa katotohanan, marami sa kanila ang hindi palaging tumpak na nag-uulat ng pagkakamali. Sa halip, ipinahihiwatig ng mga ito ang pagiging sloppiness sa code o ang posibilidad na baguhin ito gamit ang isang maayos na alternatibo. Matapos pag-aralan ng kaunti ang “Inspections → Java”, may napansin akong isang bagay. Ang mga inspeksyon sa mga kategorya ng mga posibleng error, mga problema sa numero, at mga problema sa serialization ay mas malamang na makahanap ng mga tunay na error. Sa anumang kaso, dapat kang magsagawa ng mga pagsubok sa iyong sarili at matukoy kung alin ang magiging kapaki-pakinabang para sa iyong proyekto. Dahil ginagawa ang static na pagsusuri sa mode ng pag-edit ng code, sa IntelliJ IDEA maaari mong ayusin ang mga error sa loob ng ilang segundo ng mangyari ang mga ito. Ang editor ay agad na nagha-highlight sa hindi tamang fragment ng code. Ito ay talagang maginhawa at cool! Bilang karagdagan, kung gagamitin mo ang kumbinasyong "Alt + Enter" sa isang napiling piraso ng code, maaari kang pumili ng isa sa mga opsyon upang ayusin ang error sa pamamagitan ng menu ng konteksto: Maaari mo ring malaman ang dahilan ng pagpapatakbo ng isang partikular na inspeksyon . Sa ilang mga kaso, binabawasan nito ang oras ng paghahanap: Maaari mong patakbuhin nang manu-mano ang pagsusuri sa pamamagitan ng pagpili sa “Analyze → Check Code”. O maaari kang magpatakbo ng isang indibidwal na tseke gamit ang "Pag-aralan → Patakbuhin ang tseke ayon sa pangalan". Bago gawin ito, tukuyin ang saklaw ng pagsusuri (para sa isang proyekto, module o indibidwal na file). Kapag nagpatakbo ka ng pagsusuri sa ganitong paraan, magiging available ang ilang inspeksyon na hindi gumagana sa mode ng pag-edit dahil sa pagiging kumplikado. Pagkatapos ng pagsusuri, ang mga resulta ay ipapangkat ayon sa kategorya/direktoryo sa isang hiwalay na window. Mula sa window na ito maaari kang mag-navigate sa isang tiyak na trigger ng pagpapatunay: Pinapayagan ka lamang ng IntelliJ na i-save ang resulta ng pagsusuri sa mga format na HTML at XML. Sa kasamaang palad, sa aking opinyon, ito ay pinaka-maginhawa upang gumana sa mga nakitang problema sa IDE mismo. Tandaan. Karamihan sa mga feature ng static analyzer ay available sa libreng IntelliJ IDEA Community Edition.

SonarJava

Ang SonarJava ay isang static code analyzer para sa Java mula sa SonarSource. Kasama sa listahan ng mga function nito ang:

• 150+ panuntunan sa pagtuklas ng error;
• 350+ panuntunan para sa pagkilala ng mga amoy ng code;
• 40+ panuntunan para sa pag-detect ng mga potensyal na kahinaan ;
• Pagsasama sa Maven, Gradle, Ant, Eclipse, IntelliJ IDEA, VS Code;
• Napapalawak gamit ang mga custom na panuntunan sa diagnostic;
• Espesyal na tool ng SAST: karamihan sa mga panuntunan sa diagnostic ay pinagsama-sama alinsunod sa CWE , CERT , OWASP .

Maaari mong patakbuhin ang pagsusuri pareho sa iba't ibang mga IDE (sa pamamagitan ng SonarLint plugin ) at hiwalay sa SonarQube . Ang SonarLint ay maaaring gumana nang magkatabi kasama ang built-in na IntelliJ IDEA code analyzer. Kung mag-hover ka sa isang naka-highlight na piraso ng code, madalas kang makakita ng mga babala mula sa parehong mga analyzer: Siyempre, maaari mong tingnan ang babala sa isang hiwalay na window: Sa pangkalahatan, ang kakayahang patakbuhin ang SonarJava sa iba't ibang paraan ay ginagawa itong kaakit-akit. Nagbibigay ito ng kalayaan sa mga developer na pumili ng tool kapag nagsusulat ng code.

FindBugs/SpotBugs

Sa kasamaang palad, ang FindBugs ay hindi na-update sa loob ng mahabang panahon; ang huling stable na release ay inilabas noong 2015. Ngunit natatandaan at ginagamit pa rin namin ito, dahil ito marahil ang pinakasikat na libreng static na Java code analyzer. Kung tatanungin mo ang isang developer ng Java tungkol sa static na pagsusuri, malamang na agad nilang maiisip ang FindBugs. Ang open source analyzer na SpotBugs ay naging lohikal na pagpapatuloy ng inabandunang FindBugs. Mayroon itong lahat ng mga pakinabang at disadvantages ng FindBugs. Sasabihin ng panahon kung ito ay mabuti o masama. Pansamantala, ang komunidad ng analyzer ay aktibong nagpapaunlad nito. Mga pangunahing tampok ng SpotBugs:

• 400+ panuntunan sa pagtuklas ng error;
• Pagsasama sa Ant, Maven, Gradle, Eclipse, IntelliJ IDEA;
• Napapalawak gamit ang mga custom na panuntunan sa diagnostic.

Upang makahanap ng kahina-hinalang code, ginagamit ang parehong mga pamamaraan: pagtutugma ng pattern at pagsusuri ng daloy ng data. Nakikita ng analyzer ang iba't ibang uri ng mga error na nauugnay sa multithreading, performance, vulnerabilities, code obfuscation, at iba pa. Sa IntelliJ IDEA, ganito ang hitsura ng window ng alerto: Maaaring pangkatin ang mga alerto ayon sa kategorya, klase, direktoryo, at antas ng kumpiyansa. Maaari mong sabay na tingnan ang mga alerto at dokumentasyon para sa anumang diagnostic na panuntunan. Manu-manong sinisimulan ang pagsusuri. Pagkatapos ng pagsusuri, lahat ng may problemang mga fragment ng code ay na-highlight kasama ng iba pang mga babala mula sa IntelliJ IDEA at SonarLint. Gayunpaman, may problema. Dapat mong muling patakbuhin ang pagsusuri upang i-update ang mga babala upang ipakita ang mga pagbabagong ginawa mo sa file. Mayroon ding maraming mga babala sa pagpapayo, kaya dapat na i-configure ang analyzer bago aktibong gamitin.

PVS-Studio

Ang PVS-Studio ay batay sa open source na library na Spoon. Kinukuha nito ang source code bilang input at bumubuo ng isang mahusay na disenyong modelo ng AST na may semantikong impormasyon. Batay sa modelong ito, ang analyzer ay gumagamit ng mga modernong pamamaraan tulad ng:

• Pagsusuri ng daloy ng data;
• Simbolikong pagganap;
• Mga anotasyon ng pamamaraan;
• Pagsusuri batay sa pattern.

Sa kasalukuyan, ang analyzer ay gumagamit ng higit sa 105 diagnostic na panuntunan na tumutukoy sa iba't ibang mga bahid ng code. Kabilang dito ang mga typo correction, pagpapalit ng pangalan ng null reference, unreachable code, out-of-bounds array index, paglabag sa paraan ng paggamit ng kontrata, at iba pang mga error. Maaari mong malaman ang lahat ng mga kakayahan sa diagnostic na panuntunan dito . Pangunahing pag-andar ng PVS-Studio:

• Ang analyzer ay nakatuon sa paghahanap ng mga tunay na pagkakamali;
• Bilang karagdagan sa bersyon ng CLI, mayroon ding pagsasama sa IntelliJ IDEA, Maven, Gradle, Jenkins, SonarQube;
• Kakayahang patakbuhin ang analyzer sa incremental mode;
• Tinutukoy ng analyzer ang mga potensyal na isyu sa compatibility sa Java SE API kapag naglilipat ng proyekto mula sa Java 8 patungo sa mas bagong mga bersyon;
• Kino-convert ng PVS-Studio ang ulat sa iba't ibang format na madaling gamitin: JSON, XML, HTML, TXT;
• Espesyal na tool ng SAST: karamihan sa mga panuntunan sa diagnostic ay pinagsama-sama alinsunod sa CWE , CERT , OWASP .

PMD

Ang PMD ay isang open source na static analyzer. Kinikilala nito ang mga karaniwang error sa pag-unlad: hindi nagamit na mga variable, walang laman na mga bloke, paglikha ng mga hindi kinakailangang bagay at iba pang mga problema. Ang analyzer ay gumagamit ng source code bilang input. Sa kasalukuyan, sinusuri ng PMD ang isang source file sa bawat proseso, na nagpapataw ng mga limitasyon sa pagkakumpleto ng pagsusuri. Pinapayuhan ng mga may-akda ng PMD na tipunin ang proyekto bago ang pagsusuri. Binibigyang-daan ka nitong kumuha ng impormasyon tungkol sa mga uri na ginamit sa code na sinusuri. Pangunahing pag-andar ng PMD:

• Pagsasama sa iba't ibang IDE (IntelliJ IDEA, Eclipse, NetBeans) at bumuo ng mga system (Maven, Gradle, Ant);
• Sinusuportahan ang iba't ibang mga format ng ulat ng analyzer: SARIF, CSV, IDEA, JSON, text (default), XML, HTML, TextColor at iba pa;
• Mayroong higit sa 300 mga template ng panuntunan sa diagnostic. Mga Kategorya: istilo ng coding, pinakamahuhusay na kagawian, mga bug, multithreading, pagganap at iba pa;
• Nagbibigay ng CPD (Copy-Paste Detector) kasama ng PMD na nakakakita ng mga duplicate sa code.

Kung titingnan natin ang lahat ng mga panuntunan sa diagnostic, mas nakatuon ang PMD sa paglutas ng mga problema sa istilo ng coding at paghuli ng mga halatang error. Maaaring magkasalungat ang mga panuntunan sa diagnostic sa isa't isa, kaya dapat na i-configure ang mga ito bago gamitin ang analyzer. Maaari mo ring patakbuhin ang pagsusuri sa pamamagitan ng isang plugin para sa IntelliJ IDEA, ngunit hindi ka makakapili ng mga indibidwal na file para sa pagsusuri. Ganito ang hitsura ng window ng babala: Sa palagay ko, ang pagtatrabaho sa mga babala ay hindi masyadong maginhawa, dahil hindi sila maipangkat ayon sa mga file at hindi halatang mensahe. Lalabas lang ang mga ito kapag nag-hover ka sa babala.

Konklusyon

Siyempre, bilang karagdagan sa mga analyzer na tinalakay sa itaas, may iba pang mga solusyon. Mayroong parehong bayad (Coverity, Klockwork, JArchitect) at libre (Error Prone, Infer, Checkstyle) na mga programa. Nakatuon silang lahat sa isang bagay: pagpigil sa hindi tama o potensyal na buggy code na maabot ang produksyon. Wala akong karapatang husgahan kung aling analyzer ang mas angkop para sa gawaing ito. Ngunit ang mga analyzer na bumuo ng data flow analysis at symbolic execution ay mas malamang na makahanap ng totoong bug sa code. Kung pipili ka ng static analyzer, bigyang pansin ang:

• pagsasama sa iba't ibang IDE;
• pagsasama sa mga sistema ng pagpupulong;
• kadalian ng paglulunsad ng analyzer sa server;
• ang kakayahang makakita ng mga error sa mode ng pag-edit ng code;
• ang kakayahang maginhawang magtrabaho kasama ang mga babala;
• oryentasyon ng SAST;
• porsyento ng mga maling positibo;
• pagiging kumplikado ng pagsasaayos.
• Ang kumbinasyon ng lahat ng mga kalamangan at kahinaan ay magdadala sa iyo sa bilang ng mga static na analyzer na itinuturing mong pinakamahusay.

Tandaan: Nagbigay ako ng mga halimbawa na may pagsasama sa IntelliJ IDEA, dahil madalas ko itong ginagamit.

Java heap at stack memory error

Source: DZone Titingnan natin ngayon ang mga pangunahing error na maaaring mangyari sa Java heap o stack memory, ngunit tandaan muna natin kung ano ang ibig sabihin ng dalawang terminong ito.

• Ang heap memory ay isang espesyal na lugar ng memorya kung saan nakaimbak ang mga bagay na java.
• Ang memorya ng stack ay isang lugar ng pansamantalang memorya para sa pag-iimbak ng mga variable kapag tumatawag ng isang pamamaraan.

Ang pangunahing pagbubukod na naglalarawan ng problema sa heap memory ay java.lang.OutOfMemoryError .

Java Heap Space

Ang error na ito ay nangyayari kapag ang isang Java program ay nabigo na maglaan ng isang bagong bagay sa isang heap memory area.

Lumampas sa Limitasyon sa Overhead ng GC

Ang isang Java program ay gumugugol ng masyadong maraming oras sa pagkolekta ng basura. Lumilitaw ang error na ito kapag ang pagkolekta ng basura ay tumatagal ng 98% ng oras ng programa at nabawi ang mas mababa sa 2% ng memory space.

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);
        }
    }
}

Dito naglalaman ang stringList ng reference sa aming nabuong mga string, kaya hindi maalis ng tagakolekta ng basura ang mga nabuong string mula sa memorya, ngunit sinusubukang alisin ang anumang iba pang basura sa application. Pero hindi ito sapat.

Ang Hinihiling na Laki ng Array ay Lumampas sa Limit ng VM

Ang error ay nangyayari kapag sinubukan mong maglaan ng array kapag walang sapat na espasyo sa heap.

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

Metaspace

Ang isang pagbubukod ay itinapon sa mensaheng ito kapag walang puwang sa rehiyon ng metaspace para sa impormasyon ng data ng klase.

Walang swap space (Humiling ng Laki ng Bytes para sa Dahilan. Wala sa Swap Space?)

Lumilitaw ang error kapag hindi mailaan ang memorya sa native heap o hindi sapat ang laki nito.

dahilan stack_trace_with_native_method

Nabigo ang isang native na interface ng Java o native na paraan na maglaan ng memory sa heap. StackOverFlowError - kapag napakaraming method call. Karaniwan ang isang pagbubukod ay itinapon ng isang pamamaraan na may recursion sa loob nito.

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);
    }
}