Coffee break #165. Mga package sa Java. Mga pamamaraan na ligtas sa thread para sa mga nagsisimula

Mga pakete ng Java

Source: Usemynotes Tutulungan ka ng post na ito na mas maunawaan ang mga package sa Java, maunawaan ang layunin ng mga ito at kung paano ipatupad ang mga ito.

Ano ang mga pakete sa Java

Ang Package sa Java ay isang paraan upang pagsama-samahin ang isang pangkat ng mga klase, interface, at mga subpackage. Ginagamit ang mga package upang lumikha ng mga grupo ng mga kaugnay na klase, interface, enumerasyon, at iba pa. Ang mga subpackage ay mga pakete na nasa loob ng isa pang pakete. Ang mga ito ay hindi na-import bilang default, ngunit maaari mong i-import ang mga ito nang manu-mano kung kinakailangan. Ang detalye ng pag-access ay hindi ibinibigay sa mga indibidwal na miyembro ng isang subpackage; ang mga ito ay itinuturing bilang hiwalay na mga pakete.

Ilang uri ng mga pakete sa Java:

• java.lang - ay kasama ng Java bilang default.
• java.io - naglalaman ng mga klase, pamamaraan at iba pang elementong nauugnay sa input/output.

Bakit kailangan ang mga pakete?

• Upang maiwasan ang mga salungatan sa pangalan.
• Upang magbigay ng kontroladong pag-access.
• Upang makamit ang encapsulation ng data.

Paano lumikha ng isang pakete sa Java?

Gumawa tayo ng package na tinatawag na computer . Karaniwan ang pangalan ng package ay nakasulat sa maliliit na titik. Ginagawa lamang ito upang maiwasan ang mga salungat sa pangalan sa mga pangalan ng klase. Gagawa rin kami ng interface na tinatawag na Pluggable , na makikita sa package ng computer .

package computer;

interface Pluggable {
   public void pluggedIn();
   public void pluggedOut();
}

Ngayon ay gagawa kami ng isang klase na tinatawag na PenDrive na magpapatupad ng interface sa itaas.

package computer;

public class PenDrive implements Pluggable {

   int storage = 64;

   public void pluggedIn () {
     System.out.println("Pen Drive is connected");
   }

   public void pluggedOut () {
     System.out.println("Pen Drive is removed");
   }

   public int storage() {
     return storage;
   }

   public static void main(String args[]) {
     PenDrive p = new PenDrive ();
     p.pluggedIn();
     System.out.println("Pen Drive Storage: " + p.storage());
     p.pluggedOut();
   }
}

Paano lumikha ng isang hierarchy ng package sa Java?

Kapag bumubuo ng isang hierarchy, ang mga pakete sa Java ay pinangalanan sa reverse order. Ginagawa nitong halos kapareho ang mga ito sa mga direktoryo o folder. Tulad ng sa isang personal na computer, kung saan ang isang folder ay maaaring maglaman ng isa o higit pang mga subfolder, ang parehong naaangkop sa mga pakete sa Java. Tingnan natin ang isang pakete na pinangalanang Asia.India.Kolkata . Ang lahat ng ito ay umiiral na mga folder, ngunit kung isasaalang-alang mo ang heograpiya, malinaw na ang Calcutta ay nasa India, at ang India ay nasa Asya. Ang pangunahing layunin ng isang hierarchy ay gawing mas madaling mahanap ang mga klase.

Mga uri ng mga pakete sa Java

Mga Built-in na Package

Ang mga built-in na pakete ay mga pakete na binubuo ng malaking bilang ng mga built-in na klase na bahagi ng Java API. Kasama sa mga package na ito ang:

• java.util - Ang package na ito ay naglalaman ng isang tiyak na bilang ng mga klase ng utility na ginagamit upang ipatupad ang mga istruktura ng data tulad ng naka-link na listahan, set, at iba pa. Sinusuportahan din nito ang mga pagpapatakbo ng petsa at oras at marami pang iba.
• java.net - Naglalaman ito ng mga klase na ginagamit para sa mga pagpapatakbo ng network.

Mga pakete na tinukoy ng gumagamit

Ang mga pakete na tinukoy ng gumagamit ay tinatawag na mga pakete ng gumagamit. Ang user ay maaaring manu-manong lumikha ng isang pakete at magkaroon ng maraming klase sa loob nito hangga't gusto nila.

Paano ma-access ang isang pakete mula sa isa pang pakete?

Maaari mong ma-access ang isang pakete mula sa isa pang pakete sa tatlong simpleng paraan:

• Paggamit ng asterisk sa isang import statement

Ang asterisk ( * ) character ay ginagamit upang kumatawan sa "lahat ng bagay" sa Java. Gamit ito, maaari nating i-import ang lahat ng nasa loob ng isang subpackage ng isang package. Halimbawa: Isaalang-alang ang isang pakete na pinangalanang mga tool . Kung gusto nating i-import ang lahat ng nasa loob ng package na ito kailangan nating gamitin ang import statement tulad ng:

import tools.*;

• Gamit ang import package.ClassName;

Ang pagbanggit sa pangalan ng klase sa isang pakete ay isang epektibong paraan upang i-import lamang ang mga klase na kailangan mo sa iyong programa, sa gayon ay maiiwasan ang pag-import ng mga hindi kinakailangang klase. Halimbawa: Isaalang-alang ang isang pakete na pinangalanang mga aklat . Kung gusto lang naming mag-import ng isang partikular na klase o interface mula dito (titingnan namin ang klase ng Mga Pahina ), pagkatapos ay maaari naming i-import iyon gamit ang:

import book.Pages;

• Gamit ang iyong buong pangalan

Mayroong isang paraan upang direktang gumamit ng Java package o mga klase nito sa pamamagitan ng paggamit ng kanilang ganap na kwalipikadong pangalan. Sa ganitong paraan hindi mo na kailangang i-import ang package at magagamit mo ito nang direkta sa program. Halimbawa:

java.awt.List aSimpleList = new java.awt.List();

Default na laki ng batch sa Java

Bilang default, ini-import ng Java ang java.lang package . Mayroon itong maraming klase na karaniwang ginagamit sa mga simpleng Java program tulad ng String , Integer at iba pa. Isa sa mga pinakamahalagang klase ay ang Object class , na kung saan ay matatagpuan din sa java.lang package . Ang laki ng package na ito ay batay sa mga bahagi nito: 8 interface, 37 klase, 3 enum, 27 exception, 23 uri ng error, at 5 uri ng anotasyon.

Mga Paraan ng Java na Ligtas sa Thread para sa Mga Nagsisimula

Pinagmulan: Medium Gamit ang artikulong ito, maaari mong malaman ang tungkol sa pagtatrabaho ng mga thread safe na pamamaraan sa Java. Nalaman ko na maraming mga junior/middle Java developer ang hindi nakakaunawa kung paano dapat gumana ang mga pamamaraan na ligtas sa thread sa mga totoong proyekto. At dahil karaniwan kaming nagtatrabaho sa isang multi-threaded na kapaligiran, ang kanilang tamang paggamit ay napakahalaga. Ang thread-safe na paraan ay isang paraan na maaaring tawagan mula sa maraming mga thread nang sabay-sabay nang hindi naaapektuhan ang estado ng data ng bawat isa. Ang hindi sapat na pag-unawa sa konseptong ito ay humahantong sa mga bug na mahirap hanapin at ayusin. Upang maiwasan ang gayong mga pagkakamali, tingnan natin ang mga halimbawa.

Halimbawa #1:

public static int countLetters(String input) {
    int counter = 0;

    for (Character c : input.toCharArray()) {
        if (Character.isAlphabetic(c)) {
            counter++;
        }
    }

    return counter;
}

• Ang pamamaraan ng countLetters ay static, nagbabalik ito ng isang int na halaga at tumatanggap ng isang parameter ng string bilang input.
• Ang isang primitive variable counter ay nilikha sa loob ng pamamaraan, pagkatapos ay ang loop loop sa pamamagitan ng mga character ng input string at dinadagdagan ang variable na counter sa bawat oras na ang isang letter character ay nakatagpo.

Ligtas ba ang thread na ito? Maraming developer ang nagsasabing hindi, dahil sa kasong ito mayroon kaming increment operation na hindi ligtas sa thread. Alamin natin ito. Sa Java memory model mayroon kaming stack at heap. Ang bawat thread ay may sariling stack, at ang lahat ng mga thread ay nagbabahagi ng parehong heap. Sa pagsasaalang-alang na ito, ang stack data ay palaging ligtas sa thread, ngunit ang heap data ay hindi. Ang stack ay nag-iimbak ng mga primitive at object reference. Ang heap ay naglalaman ng mga bagay mismo. Nangangahulugan ito na sa halimbawa ng code na ito, ang bawat thread ay nag-iimbak ng sarili nitong variable na counter sa stack at walang anumang epekto sa data ng iba pang mga thread, kaya ang pamamaraan ay thread safe . Tandaan na ang input String value ay isa ring object, ngunit ang String at primitive wrapper ( Integer , Long , Double , Boolean at iba pa) ay ligtas sa thread dahil hindi nababago ang mga ito.

Halimbawa #2:

public static int countLetters2(String input) {
    List<Character> listCounter = new ArrayList<>();

    for (Character c : input.toCharArray()) {
        if (Character.isAlphabetic(c)) {
            listCounter.add(c);
        }
    }

    return listCounter.size();
}

Ginamit ng code na ito ang parehong lohika gaya ng unang halimbawa, ngunit gumamit ng List object sa halip na isang primitive int variable . Mula sa nakaraang bahagi alam namin na ang mga bagay sa Java ay naka-imbak sa heap at List ay isang bagay. Alam din namin na ang stack ay nag-iimbak ng mga sanggunian sa mga bagay sa heap. Sa halimbawa #2, ang bawat thread ay lumilikha ng bagong ArrayList object : at ang listCounter variable ay nag-iimbak ng reference sa object nito sa heap, kaya walang ibang thread ang makakapagpabago sa object na iyon.

List<Character> listCounter = new ArrayList<>();

Nangangahulugan ito na ang pamamaraang ito ay ligtas sa thread.

Halimbawa #3:

public class CounterUtil { // singleton

    List<Character> listCounter = new ArrayList<>();

    public int countLetters3(String input) {
        for (Character c : input.toCharArray()) {
            if (Character.isAlphabetic(c)) {
                listCounter.add(c);
            }
        }

        return listCounter.size();
    }
}

Sa halimbawang ito, mayroon kaming singleton (ito ay mahalaga) na klase na CounterUtil na may pandaigdigang variable listCounter . Ang variable na ito ay nilikha kasabay ng singleton instance. Kapag maraming thread ang tumawag sa countChars3 method , lahat sila ay gumagamit ng parehong global variable listCounter , na nag-iimbak ng reference sa parehong bagay sa heap, at ang mga thread doon ay makakaimpluwensya sa isa't isa. Samakatuwid maaari nating tapusin na ang pamamaraang ito ay hindi ligtas sa thread. At kahit na baguhin natin ang List<Character> listCounter sa isang primitive variable int counter , hindi rin ito magiging thread safe dahil lahat ng thread ay gagamit ng parehong primitive variable.

Huling halimbawa:

public static int countLetters4(List<Character> inputList) {
    List<Character> listCounter = new ArrayList<>();

    for (Character c : inputList) {
        if (Character.isAlphabetic(c)) {
            listCounter.add(c);
        }
    }

    return listCounter.size();
}

Ang paraan ng countLetters4 ay tumatanggap ng isang listahan ng mga character sa halip na isang String parameter . Dito hindi namin magagarantiya na ang pamamaraang ito ay ligtas sa thread. Bakit? Dahil hindi namin matiyak kung paano gagamitin ng mga developer ang pamamaraang ito. Kung binago ng isa pang thread mula sa labas ang data sa inputList kasabay ng aming counterLetters4 method , maaari itong makaapekto sa huling resulta.

Konklusyon

Tumingin lang kami sa apat na halimbawa, at hindi nila sinasaklaw ang lahat ng aspeto ng kaligtasan ng thread sa mga proyekto ng Java, ngunit ang mga ito ay isang magandang lugar upang magsimula. Sa susunod na makakita ka ng paraan sa iyong code, tanungin ang iyong sarili, "Ligtas ba ang thread ng pamamaraang ito?" At sa lalong madaling panahon ay malinaw mong mauunawaan ang sagot.