Coffee break #159. Life cycle ng isang thread sa Java. Mga Functional na Interface at Default na Paraan sa Java 8

Lifecycle ng isang Thread sa Java

Pinagmulan: Medium Tinatalakay ng artikulong ito ang iba't ibang estado ng lifecycle ng mga thread sa Java. Ang siklo ng buhay ng isang thread sa Java ay pangunahing binubuo ng mga paglipat sa iba't ibang mga estado, na nagsisimula sa kapanganakan ng thread at nagtatapos sa pagwawakas ng thread. Handa nang tumakbo ang isang thread kapag ito ay ginawa at sinimulan sa pamamagitan ng pagtawag sa start() na paraan sa Thread class . Kapag ang pamamaraan ng sleep() o wait() ng klase ng Thread ay tinawag na , ang thread ay nagiging hindi magagamit. Upang pamahalaan ang mga thread sa programmatically, mahalagang kilalanin ang estado ng thread. Unawain natin kung paano tinutukoy ng life cycle ng isang Java thread ang estado nito. Narito ang sinasabi ng dokumentasyon ng Java tungkol dito: Ang isang thread ay isang landas ng pagpapatupad ng programa na maaaring pumasok sa isa sa limang estado sa panahon ng siklo ng buhay nito:

1. Bago
2. Runnable
3. Tumatakbo
4. Naka-block
5. Patay

1. Ang bagong (newborn state) ay nangyayari kapag gumawa ka ng Thread object sa Thread class. Nalikha ang daloy at nasa "newborn" na estado. Iyon ay, kapag ang isang thread ay nilikha, ito ay pumapasok sa isang bagong estado, ngunit ang start() na pamamaraan ay hindi pa tinatawag sa halimbawa. 2. Runnable. Ang estado na ito ay nangangahulugan na ang thread ay handa nang tumakbo. Kapag ang start() na paraan ay tinawag sa isang bagong thread, ito ay magiging handa upang magsimula. Sa ganitong estado, naghihintay ang thread hanggang sa maging available ang processor (oras ng CPU). Iyon ay, ang thread ay nagiging isang pila (serye) ng mga thread na naghihintay na maisakatuparan. 3. Tumatakbo (running state). Ang pag-execute ay nangangahulugan na ang processor ay naglaan ng time slot para sa thread upang maisagawa. Ito ang estado kung saan gumaganap ang thread sa aktwal na function nito. 4. Naka-block (naka-block na estado). Ang isang thread ay nasa isang naka-block na estado kapag ito ay nag-pause, natutulog, o naghihintay ng ilang oras upang matugunan ang isang partikular na kundisyon. 5. Patay na Estado. Nangyayari ang kundisyong ito kapag natapos ng run() na pamamaraan ang pagpapatupad ng mga tagubilin. Awtomatikong hihinto o mapupunta ang thread sa Dead State. Sa madaling salita, kapag ang isang thread ay lumabas sa run() method , ito ay magwawakas o maging patay.

Mga Functional na Interface at Default na Paraan sa Java 8

Source: Medium Sa artikulong ito, matututunan mo ang tungkol sa ilan sa mga pagbabagong ipinakilala sa Java 8, katulad ng mga functional na interface at mga default na pamamaraan.

Ano ang mga Default na Paraan?

Alam namin na ang mga abstract na klase ay maaaring magkaroon ng abstract at non-abstract na mga pamamaraan (mga pamamaraan na ipinapatupad), ngunit ang mga interface ay 100% abstract (lahat ng mga pamamaraan na ito ay may lagda lamang at walang pagpapatupad). Ngunit paano kung kailangan namin ng isang interface sa halip na isang klase at karaniwang pag-andar sa lahat ng ipinatupad na mga klase? Dahil pagkatapos ay paulit-ulit ang code ng pagpapatupad sa bawat klase na nagpapatupad ng interface. Upang maiwasan ito, idinagdag ng Java 8 ang default na keyword . Kung mayroon kaming paraan na ipinatupad sa isang interface, dapat na italaga ang default na keyword sa paraang iyon, kung hindi, magkakaroon kami ng runtime error.

Ano ang isang functional na interface?

Ang mga functional na interface ay walang iba kundi mga interface na may isang abstract na pamamaraan at anumang bilang ng mga standard o static na pamamaraan. Ang isang halimbawa ng functional na interface ay Comparable, na mayroong isang abstract na paraan, compareTo() . Sa turn, ang Runnable ay may run() na paraan at iba pa. Maaari rin kaming kumatawan sa isang functional na interface gamit ang @FunctionalInterface annotation. Tinitiyak nito na ang isang interface ay mayroon lamang isang abstract na pamamaraan:

@FunctionalInterface
public interface MyfunctionalInterface{
   public void myabstractmethod();
   public static void method1(){
       //Имплементация
    }
   public default void method2(){
       //Имплементация
    }
}

Mga uri ng mga functional na interface

Consumer - tumatagal ng isang argumento at walang ibinalik.

• Ang tatlong variant ng Consumer ay DoubleConsumer, IntConsumer at LongConsumer (depende sa uri ng mga argumentong tinatanggap nila).
• Bi-Consumer - tumatagal ng dalawang argumento at walang ibinalik.

Predicate - tumatagal ng isang argument at nagbabalik ng boolean value.

• Ang tatlong variant ng Predicate ay DoublePredicate, IntPredicate at LongPredicate (depende sa uri ng mga argumentong tinatanggap nila).
• Bi-Predicate - kumukuha ng dalawang argumento at nagbabalik ng boolean value.

Function - tumatagal ng isang argument at nagbabalik ng isang value.

• Maraming bersyon ng mga function ang available bilang mga uri ng argumento, na int , long at double ang pinakakaraniwang ginagamit.
• Bi-Function - tumatagal ng dalawang argumento at nagbabalik ng isang halaga.
• Ang Unary at Binary operator ay nagpapatupad ng Function at Bi-Function ayon sa pagkakabanggit, ngunit ang karagdagang kundisyon dito ay ang input at output ay dapat magkapareho at ng parehong uri.

Supplier - Hindi tumatanggap ng anumang input ngunit nagbabalik ng isang halaga. Iba't ibang bersyon ng Supplier: BooleanSupplier, IntSupplier, LongSupplier at DoubleSupplier, kung saan ang mga uri ng pagbabalik ay ang mga kaukulang primitive.