Interfață rulabilă în Java: implementare, pași și erori

Publicat: 2021-05-02

Cuprins

Introducere

O interfață rulabilă în Java este o interfață ale cărei instanțe pot rula ca un Thread. În timpul lucrului cu Threads, interfața rulabilă acționează ca un element de bază al limbajului de programare Java. Clasele Java create pentru a rula Threads trebuie să implementeze această interfață. Acest articol vă va oferi o înțelegere profundă a interfeței rulabile în Java și a procesului de implementare.

Ce este interfața rulabilă în Java?

O interfață rulabilă este o interfață care conține o singură metodă. Programul Java definește această metodă unică în pachetul java.lang și o apelează la execuția clasei thread. Acesta oferă un șablon pentru obiectele pe care o clasă le poate implementa folosind Threads. Puteți implementa interfața rulabilă în Java în unul dintre următoarele moduri:

  • Folosind threadul subclasei
  • Suprascrierea metodei run().

Java nu permite moșteniri multiple în program. Puteți extinde o singură clasă, iar atunci când extindeți o clasă de fire, aceasta consumă mai multă memorie, timp de calcul și alte resurse. Prin urmare, adaugă costul general de utilizare a metodelor suplimentare. Dintre cele două opțiuni de mai sus, este mai bine să utilizați o interfață rulabilă pentru a crea un fir. Pentru a face acest lucru, trebuie să furnizați implementarea metodei run().

Pași pentru crearea unui thread folosind interfața rulabilă în Java

Efectuați următorii pași pentru a crea un fir folosind interfața rulabilă în Java .

  1. Creați o clasă de fire care va implementa interfața rulabilă.
  2. În clasa thread-ului, scrieți o funcție care să înlocuiască metoda run().
  3. Creați o instanță a clasei Thread.
  4. Instanța thread-ului are un constructor care acceptă obiectul rulabil. Transmite acest obiect ca parametru instanței firului.
  5. În cele din urmă, apelați metoda de pornire a instanței firului.

Citiți și: Idei și subiecte de proiecte Java

Implementarea interfeței rulabile în Java

Implementarea metodei run() este cea mai simplă modalitate de a crea un fir nou. Acționează ca punct de plecare pentru crearea unui nou Thread. Implementarea interfeței rulabile folosește codul din interiorul metodei run() și îl execută pe un fir concurent. Puteți fie să invocați clasa, să creați variabile noi sau să apelați acțiunea în metoda run() pentru a implementa interfața rulabilă în Java . Programul se asigură că firul de execuție este inactiv până când imprimă declarația return în cod.

clasă publică TestRunnableInterface {

public static void main(String[] args) {

System.out.println(„De la metoda primară(): ” + Thread.currentThread().getName());

System.out.println(„Implementarea interfeței rulabile în Java ”);

Instanță care poate fi executată = runnable() nouă {@Override

public void run() {

System.out.println(„De la metoda run(): ” + Thread.currentThread().getName());

}

};

System.out.println(„Creați o nouă instanță a obiectului fir.”);

Test de fire = thread nou (instanță);

System.out.println(„Se execută firul!”);

test.start();

}

}

Ieșire

Din metoda primary(): main

Implementarea interfeței rulabile în Java

Creați o nouă instanță a obiectului fir.

Din metoda run(): Thread-0

Erori întâlnite la implementarea interfeței rulabile în Java

Metoda run() aruncă o eroare de excepție de rulare atunci când programul se întrerupe din cauza unei erori de sintaxă sau de cod. Dacă o mașină virtuală Java nu detectează erorile, atunci firul creat se ocupă de excepția ratată de JVM. Managerul de excepții imprimă excepția și oprește programul.

import java.io.FileNotFoundException;

clasă publică TestRunnableInterface {

public static void main(String[] args) {

System.out.println(„Firul principal este: ” + Thread.currentThread().getName());

Thread test = nou Thread(new TestRunnableInterface().new DemoInstance());

test.start();

}

Clasa privată DemoInstance implementează Runnable {

public void run() {

System.out.println(Thread.currentThread().getName() + „, invocând metoda run()!”);

încerca {

aruncă o nouă excepție FileNotFoundException();

}

catch(FileNotFoundException demo) {

System.out.println(„Am prins o eroare!”);

demo.printStackTrace();

}

}

}

}

Ieșire

Firul principal este: principal

Thread-0, invocând metoda run()!

Am prins o eroare!

java.io.FileNotFoundException

la TestRunnableInterface$DemoInstance.run(Example.java:21)

la java.lang.Thread.run(Thread.java:748)

Clasa TestRunnableInterface din programul de mai sus nu aruncă excepția FileNotFoundException. Mașina virtuală Java are grijă de excepțiile care ar fi trebuit să fie gestionate de clasa TestRunnableInstance.

Cazul de utilizare al interfeței rulabile în Java

Interfața rulabilă în Java este utilizată într-un scenariu de rețea în care serverul primește mai multe cereri de conexiune de la clienți. Interfața rulabilă din Java se ocupă rapid și eficient de programare multi-thread.

Învață cursuri de dezvoltare software online de la cele mai bune universități din lume. Câștigă programe Executive PG, programe avansate de certificat sau programe de master pentru a-ți accelera cariera.

Concluzie

Pe scurt, o interfață rulabilă în Java este întotdeauna o alegere mai bună în comparație cu threadul de subclasă atunci când vine vorba de crearea de fire în Java. Codul folosit în articol are doar scop explicativ. Puteți modifica declarațiile date în exemple în funcție de cerințele dvs. În acest articol, am aflat despre interfața rulabilă în Java și cum puteți crea un fir prin implementarea interfeței rulabile în Java .

Puteți încerca codul pentru a vă consolida cunoștințele constructorului Java . Dacă doriți să obțineți o înțelegere aprofundată a Java, consultați cursul upGrad Executive PG Program în Full Stack Development . Acest curs este conceput pentru profesioniști care lucrează și oferă pregătire riguroasă și asistență la locul de muncă cu companii de top.

Ce este multithreading în Java?

Multithreadingul este un concept în Java în care sarcinile sunt executate simultan. Permite unui program să efectueze mai multe sarcini diferite simultan, în loc să aștepte ca o singură sarcină să fie finalizată. Este unul dintre cele mai populare subiecte ale dezvoltatorilor Java și Java. Multithreadingul este una dintre caracteristicile foarte puternice ale java. Utilizează eficient CPU rulând mai multe fire. Java are o construcție specială numită thread. Un fir este practic un proces software care poate executa o secvență arbitrară de instrucțiuni de cod de octet Java. Execuția fiecărui thread este independentă de alte fire. Dezvoltatorii pot crea un fir nou oricând, iar JVM-ul se va ocupa de execuția acestui fir. Acest lucru ajută la dezvoltarea unei aplicații foarte scalabile și receptive.

Ce este interfața rulabilă în Java?

Interfața rulabilă este folosită pentru a scrie aplicații care pot rula într-un fir separat. Orice clasă care implementează interfața rulabilă se numește thread. Codul firului de execuție este executat de interpret după pornirea firului de execuție. Puteți implementa interfața rulabilă și puteți crea propriul program multithreading. Există două moduri de a implementa această interfață. Prima este prin utilizarea subclasei thread. Celălalt este prin suprascrierea metodei run().

Cum funcționează de fapt multithreading-ul?