Când vine vorba de Java NIO (nou intrare/ieșire), este un set puternic de API-uri Java care oferă un sistem I/O orientat spre tampon, care nu blochează. În calitate de furnizor NIO, am asistat de prima dată la o varietate de greșeli comune pe care dezvoltatorii le fac atunci când folosesc Java Nio. În această postare pe blog, voi aprofunda aceste greșeli și voi oferi informații despre cum să le evit.
1.. Înțelegerea greșită a naturii non -blocare
Unul dintre cele mai fundamentale concepte din Java Nio este natura sa necompletată. Cu toate acestea, mulți dezvoltatori înțeleg greșit acest concept. În I/O tradițională, operațiunile precum citirea dintr -o priză sau un fișier sunt blocate, ceea ce înseamnă că firul este pus în așteptare până la finalizarea operației. În schimb, Java Nio permite unui fir să efectueze alte sarcini în timp ce așteaptă o operație de I/O să se termine.
O greșeală obișnuită este utilizarea canalelor non -blocare într -un mod care să le neg avantajul. De exemplu, unii dezvoltatori ar putea scrie un cod care sondează constant un canal care nu blochează pentru a verifica dacă datele sunt disponibile. Acest lucru poate duce la utilizarea ridicată a procesorului, deoarece firul funcționează continuu într -o buclă strânsă, consumând resurse chiar și atunci când nu există date noi.
import java.nio.channels.socketchannel; import java.io.ioexception; public class BadnonBlockingExample {public static void main (String [] args) aruncă ioexception {socketchannel canal = socketchannel.open (); canal.configureblocking (fals); while (true) {if (canal.read (null)> 0) {// datele procesului}}}}Pentru a evita această greșeală, dezvoltatorii ar trebui să utilizezeSelectorÎn Java Nio. OSelectorpermite unui singur fir să monitorizeze mai multe canale pentru diverse evenimente, cum ar fiOp_read,Op_write, etc. În acest fel, firul poate aștepta eficient până când apare un eveniment pe unul dintre canalele înregistrate.
import java.nio.channels.socketchannel; import java.nio.channels.selector; import java.nio.channels.selectionkey; import java.io.ioexception; import java.util.iterator; public class GoodNonBlockingExample {public static void main (String [] args) aruncă ioexception {socketchannel canal = socketchannel.open (); canal.configureblocking (fals); Selector selector = selector.open (); Channel.Register (Selector, SelectionKey.op_read); while (true) {selector.select (); Iterator <SelectionKey> keys = selector.selectedKeys (). Iterator (); while (keys.hasNext ()) {SelectionKey Key = keys.next (); if (key.isReadable ()) {// procesul de proces} keys.remove (); }}}}2. Managementul bufferului necorespunzător
Tampoanele sunt în centrul Java Nio. Acestea sunt folosite pentru a stoca date citite de pe canale sau date pentru a fi scrise pe canale. O greșeală comună este gestionarea necorespunzătoare a tamponului, în special în ceea ce priveștepoziţie,limită, șicapacitatea tamponului.
capacitatea unui tampon este numărul maxim de elemente pe care le poate deține.poziţieindică locația curentă unde va fi citit sau scris următorul element, iarlimităeste indexul după ultimul element valid.
De multe ori dezvoltatorii uită să arunce tamponul după ce a scris date în el înainte de a citi.flip ()Metoda stabileștelimităla curentpoziţieși apoi reseteazăpoziţiepână la 0. Fără a răsturna tamponul, operația de citire va începe de la sfârșitul datelor care tocmai au fost scrise, ceea ce duce la rezultate neașteptate.
import java.nio.byteBuffer; public class BuffeMangementMistake {public static void main (String [] args) {byteBuffer Buffer = byteBuffer.Allocate (1024); String data = "salut, java nio!"; Buffer.put (data.getBytes ()); // greșeală: nu apelați flip () byte [] rezultat = byte nou [buffer.capacity ()]; Buffer.get (rezultat); System.out.println (nou șir (rezultat)); }}Modul corect este să apelațiflip ()Înainte de a citi din tampon.
import java.nio.byteBuffer; public class CorrectBuffeManAgement {public static void main (String [] args) {byteBuffer buffer = byteBuffer.Allocate (1024); String data = "salut, java nio!"; Buffer.put (data.getBytes ()); Buffer.flip (); byte [] rezultat = byte nou [buffer.remaining ()]; Buffer.get (rezultat); System.out.println (nou șir (rezultat)); }}O altă greșeală conexă este să nu ștergeți sau să compatați tamponul atunci când nu mai este nevoie. Nerespectarea acestui lucru poate duce la scurgeri de memorie, în special în aplicațiile de lungă durată.
3. Ignorarea manipulării excepțiilor
Manevrarea excepțiilor este crucială în orice programare, iar Java Nio nu face excepție. Cu toate acestea, mulți dezvoltatori ignoră o gestionare adecvată a excepțiilor atunci când lucrează cu canale Java NIO și selectori.
Când lucrați cu canale de rețea, de exemplu, pot apărea diverse excepții, cum ar fiIoexceptionCând există o eroare de rețea sauÎnchischanlexceptionCând canalul este deja închis. Ignorarea acestor excepții poate duce la problemele de depanare grele - la - de depanare din aplicație.
import java.nio.channels.socketchannel; import java.io.ioexception; public class NoExceptionHandling {public static void main (String [] args) {try {socketchannel canal = socketchannel.open (); // unele operații} captură (excepția e) {// fără manipulare corectă}}}Dezvoltatorii ar trebui să se ocupe de excepții cu grație. De exemplu, dacă este unIoexceptionapare în timp ce citiți de pe un canal, aplicația poate înregistra eroarea, poate închide canalul corect și poate lua măsuri de recuperare adecvate.
import java.nio.channels.socketchannel; import java.io.ioexception; import java.util.logging.level; import java.util.logging.logger; public class PropeRexceptionHandling {private static final logger logger = logger.getLogger (proprexceptionhandhingling.class.getName ()); public static void main (String [] args) {try {socketchannel canal = socketchannel.open (); ) // Închideți canalul și efectuați acțiuni de recuperare}}}4. Nu luați în considerare siguranța firului
Canalele Java NIO și selectoarele nu sunt întotdeauna în siguranță. De exemplu, dacă mai multe fire încearcă să înregistreze un canal cu un selector simultan, acesta poate duce la condiții de cursă.
Dezvoltatorii trebuie să asigure o sincronizare adecvată atunci când accesați resurse NIO partajate. O modalitate de a face acest lucru este folosind încuietori. Cu toate acestea, utilizarea excesivă a încuietorilor poate duce, de asemenea, la degradarea performanței.
import java.nio.channels.socketchannel; import java.nio.channels.selector; import java.nio.channels.selectionkey; import java.io.ioexception; import java.util.concurrent.locks.lock; import java.util.concurrent.locks.reentrantlock; public class ThreadSafetyExample {private static final Lock Lock = new ReentrantLock (); Selector privat de selecție statică; public static void main (String [] args) aruncă ioexception {selector = selector.open (); Thread t1 = new thread (() -> {try {socketchannel canal = socketchannel.open (); blocaj.lock (); try {channel.register (selector, selectykey.op_read);} în sfârșit {Lock.unlock ();}} catch (IoException e) {e.PrintStackTrace ();}}); Thread t2 = new thread (() -> {try {socketchannel canal = socketchannel.open (); blocaj.lock (); try {channel.register (selector, selectykey.op_read);} în sfârșit {Lock.unlock ();}} catch (IoException e) {e.PrintStackTrace ();}}); t1.start (); t2.start (); }}5. Scarabilitatea cu vedere
Java NIO este proiectat pentru a fi scalabil, în special în aplicații cu randament ridicat și cu latență scăzută. Cu toate acestea, unii dezvoltatori trece cu vederea scalabilitatea atunci când își proiectează aplicațiile.
De exemplu, dacă o aplicație folosește un singur fir pentru a gestiona un număr mare de canale, poate deveni un blocaj. În astfel de cazuri, dezvoltatorii ar trebui să ia în considerare utilizarea unui grup de fir pentru a distribui volumul de muncă între mai multe fire.
import java.nio.channels.socketchannel; import java.nio.channels.selector; import java.nio.channels.selectionkey; import java.io.ioexception; import java.util.concurrent.executorService; import java.util.concurrent.executors; public class scalabilityExample {private static final int thread_pool_size = 10; privat static final executorService executor = executori.newfixedthreadpool (thread_pool_size); public static void main (String [] args) aruncă ioexception {selector selector = selector.open (); // înregistrați canalele în timp ce (true) {selector.select (); for (SelectionKey Key: Selector.SelectedKeys ()) {executor.submit () -> {if (key.isReadable ()) {// date de proces}}); }}}}Concluzie
În calitate de furnizor NIO, înțeleg corect importanța utilizării Java Nio. Prin evitarea acestor greșeli comune, dezvoltatorii pot construi aplicații mai eficiente, mai fiabile și scalabile. Dacă sunteți interesat să aflați mai multe despre Java Nio sau căutați componente NIO de înaltă calitate, suntem aici pentru a vă ajuta. Vă putem oferi sfaturi și soluții profesionale adaptate nevoilor dvs. specifice. Indiferent dacă lucrați la un proiect la scară mică sau la o aplicație de întreprindere la scară largă, expertiza noastră în NIO poate face o diferență semnificativă.
Dacă sunteți interesat și de mașinile electrice, puteți consultaMașină electrică NIO ET5.
Dacă aveți întrebări sau sunteți gata să începeți o discuție de achiziții, nu ezitați să vă contactați. Așteptăm cu nerăbdare să lucrăm cu dvs. pentru a vă atinge obiectivele proiectului.
Referințe
- „Java Nio” de Ron Hitchens
- Documentația Oracle Java pe NIO