Menu

Multithreading v Javě - výuka s příklady

multithreading java tutorial with examples

Vyzkoušejte Náš Nástroj Pro Odstranění Problémů

Tento výukový program vysvětluje vše o multithreadingu v Javě, implementaci souběžnosti, životním cyklu vlákna, příkladu třídy vlákna, vláknu používajícím rozhraní Runnable:

Souběžnost ve světě počítačů je schopnost systému (ať už je to aplikace, počítač nebo programovací jazyk) spouštět několik instancí programu nebo aplikace paralelně.

Souběžným spuštěním instancí nebo programů zajišťujeme vysokou propustnost a vyšší výkon, protože můžeme využívat nevyužité zdroje, jako je hardware operačního systému atd. Například, pokud má systém několik procesorů, může aplikace tyto procesory efektivně využívat a zvýšit propustnost.

=> Navštivte zde exkluzivní sérii výukových programů Java.

Multithreading v Javě

Co se naučíte:

Co je multithreading v Javě

V Javě lze vlákna vnímat jako páteř souběžnosti. Vlákno je spustitelná, lehká jednotka, která přistupuje ke sdíleným prostředkům i k vlastnímu zásobníku volání.

Aplikace Java je jeden proces a v rámci této aplikace můžeme mít více vláken, abychom dosáhli souběžnosti.

Víme, že aplikace spuštěná v systému může mít více instancí a obvykle se jim říká multi-doc aplikace. Tyto instance aplikace se nazývají procesy. Každému z těchto procesů je přiřazena prováděcí jednotka známá jako vlákno.

V závislosti na operačním systému a požadavcích aplikace lze procesu přiřadit buď jedno vlákno, nebo více vláken. Když je procesu aplikace přiřazeno více vláken, musíme tyto více vláken spustit současně.

' Tato technika provádění nebo spouštění více vláken současně nebo souběžně je známá jako multithreading . “

Vícevláknové zpracování jednoduše znamená, že - ve stejné aplikaci je spuštěno více podprocesů.

Programovací jazyk Java má integrovanou podporu pro vícevláknové zpracování.

multithreading

Ve výše uvedeném diagramu je znázorněno vícevláknové zpracování. Jak je znázorněno, v aplikaci běží více podprocesů.

Například, desktopová aplikace poskytující funkce jako úpravy, tisk atd. je aplikace s více vlákny. V této aplikaci, protože tisk je proces na pozadí, můžeme provádět úpravy dokumentů a tisk dokumentů souběžně přiřazením těchto funkcí ke dvěma různým vláknům.

Vlákna ve vícevláknových aplikacích běží paralelně navzájem souběžně. Multithreading je tedy také součástí souběžnosti v Javě. Všimněte si, že i když existuje více vláken, sdílejí oblast paměti, čímž šetří paměť. Vlákna také mohou snadno přepínat kontexty v žádném okamžiku.

Vícevláknový proces je hlavně užitečný, protože poskytuje souběžné provádění dvou nebo více částí aplikace. To umožňuje aplikaci maximálně využít čas CPU a doba nečinnosti je omezena na minimum.

Následuje několik termínů, které bychom měli znát v souvislosti s vícevláknovým prostředím, protože se často používají.

Multitasking: V multitaskingu se provádí více než jeden úkol současně.

Multithreading: Multithreading, jak již bylo zmíněno, je proces provádění více vláken současně.

převodník z youtube na mp3 s úpravami

Vícenásobné zpracování: V multiprocesingu se provádí více než jeden proces současně. Podobně jako multitasking, ale zde je zapojen více než jeden procesor.

Paralelní zpracování: Paralelní zpracování je technika, kdy v počítačovém systému pracuje současně více procesorů.

Po diskusi o multithreadingu vyvstává otázka, proč vůbec multithreading potřebujeme?

Výhody multithreadingu

Multithreading má různé výhody, které napomáhají efektivnímu programování.

Následující body to objasní.

# 1) Efektivní využití systémů s jedním CPU

Pokud je v systému pouze jeden procesor s jediným vláknem, je čas CPU zbytečný. Když je vlákno zaneprázdněno pomocí jiných zdrojů, jako je IO, CPU je nečinný. Můžeme to vylepšit a lépe využívat CPU tím, že budeme mít vícevláknové aplikace.

Použitím vícevláknového zpracování, pokud je jedno vlákno provedeno pomocí CPU, může ho druhé vlákno využít. S více vlákny se doba nečinnosti CPU výrazně zkrátí.

# 2) Efektivní využití více systémů CPU

Stejně jako jednotlivé CPU, i v systémech s více CPU mohou aplikace s více vlákny efektivně využívat více CPU.

# 3) Vylepšená uživatelská zkušenost s ohledem na schopnost reagovat a férovost

Reakce systému se zlepšuje u vícevláknových aplikací. Nezažijeme „GUI visí“ když máme více podprocesů provádějících různé úkoly v aplikaci a uživatelé nemusí dlouho čekat, než dostanou odpověď na své požadavky.

Podobně jsou uživatelé řádně službami v systémech s více vlákny.

Jak implementovat souběžnost v Javě

První třída, pomocí které můžeme implementovat souběžnost v Javě, je java.lang.Thread třída. Tato třída Thread tvoří základ souběžnosti v Javě.

Také máme java.lang.Runnable rozhraní, které může být implementováno třídou Java k abstrakci chování vlákna. Pro pokročilý vývoj aplikací můžeme využít java.util.concurrent balíček dostupný od Java 1.5.

V budoucnu budeme podrobně diskutovat o souběžnosti v Javě. Pojďme v tomto tutoriálu probrat a pochopit koncept vláken v Javě. V našich následujících výukách o multithreadingu prozkoumáme různé koncepty multithreadingu a souběžnosti.

Co je vlákno v Javě

Jedno vlákno lze definovat jako nejmenší a nejlehčí jednotku zpracování. V Javě se vlákna používají v programech využívajících třídu „Thread“.

Vlákna Java jsou dvou typů:

Typy vláken v Javě

# 1) Uživatelské vlákno: uživatelské vlákno je vytvořeno při prvním spuštění aplikace. Pak můžeme vytvořit tolik podprocesů uživatelů a démonů.

# 2) Daemon vlákno: vlákna démona se používají hlavně na pozadí a používají se k úkolům, jako je čištění aplikace atd.

Vlákna snižují náklady na údržbu aplikace. Také snižuje režii aplikace.

Níže je uveden příklad jednoho vlákna:

public class Main{ public static void main (String () args){ System.out.println('This is a thread'); } }

Výše uvedený program zobrazí „Toto je vlákno“, protože při spuštění aplikace je vytvořeno uživatelské vlákno. Ve výše uvedeném programu je hlavní funkcí výchozí bod aplikace a vytváří uživatelské vlákno.

Životní cyklus vlákna

Následující diagram znázorňuje životní cyklus vlákna v Javě.

Životní cyklus vlákna v Javě

Jak je znázorněno ve výše uvedeném diagramu, vlákno v Javě má ​​následující stavy:

# 1) Nové: Zpočátku má vlákno právě vytvořené z třídy vláken stav „nového“. Je teprve zahájeno. Toto vlákno se také nazývá ‚Rodná nit ' .

# 2) Spustitelné: V tomto stavu je instance vlákna vyvolána pomocí metody 'Start' .

# 3) Běh: Vyvolá se počáteční metoda instance podprocesu a podproces zahájí provádění. Toto je spuštěný stav. Většinou plánovač naplánuje a spravuje vlákna.

# 4) Blokováno: V aplikaci je více vláken. Tato vlákna musí čekat na další, protože jejich provedení musí být synchronizováno.

# 5) Ukončeno: Jakmile je proces provádění vlákna ukončen, vlákno je ukončeno nebo je zastaveno jeho provádění.

Nejprve je tedy vytvořeno vlákno, poté naplánováno a později plánovač vlákno provede. Zatímco běžící vlákno může být blokováno nebo pozastaveno z důvodu jiné aktivity. Poté je obnoveno a během zpracování je vlákno provedeno.

špionážní aplikace pro iPhone a Android

Priority vláken

Priorita vlákna rozhoduje o tom, jak má být jedno vlákno zacházeno s ohledem na ostatní vlákna v aplikaci. Prioritou vlákna je celé číslo.

Níže jsou uvedeny některé body, které je třeba pamatovat na priority vláken:

  • Priority podprocesů jsou celá čísla.
  • Pomocí priority vlákna se můžeme rozhodnout, kdy bychom měli přepnout z jednoho vlákna v běžícím stavu na jiné. Toto je proces přepínání kontextu, při kterém přepínáme kontexty vláken.
  • Vlákno může kdykoli dobrovolně uvolnit svoji kontrolu nad CPU. Pak může převzít vlákno s nejvyšší prioritou.
  • Podobně vlákno s vyšší prioritou může předcházet jakémukoli jinému vláknu s nižší prioritou.
  • Třída vlákna poskytuje metodu setPriority (), která se používá k nastavení priority vlákna.
  • Můžeme také použít konstanty MIN_PRIORITY, MAX_PRIORITY nebo NORM_PRIORITY místo celých čísel.

Vytvořte vlákno

Můžeme vytvořit vlákno jedním z následujících způsobů:

  1. Rozšíření třídy Java „Thread“.
  2. Implementace „Runnable“.

Rozšíření třídy Java „Thread“

Třída Thread obsahuje konstruktory a metody, které nám umožňují vytvářet a provádět operace s objektem vlákna. Třída Thread interně implementuje Runnable rozhraní a také rozšiřuje třídu Object.

Následující tabulka poskytuje souhrn různých konstruktorů a metod třídy Thread ().

Stavitel/PrototypPopis
spát spánek ve veřejné nouzi (dlouhé milisekundy)Provádění aktuálního vlákna je zastaveno na zadané milisekundy.
Konstruktor vlákna () Vlákno()Výchozí konstruktor pro vytvoření objektu vlákna.
Vlákno (název řetězce)Konstruktor pro vytvoření objektu Thread se zadaným názvem.
Vlákno (Runnable r)Vytvořte instanci vlákna se zadaným objektem rozhraní Runnable.
Thread (Runnable r, String name)Vytvořte instanci vlákna se zadaným Runnable objektem rozhraní a křestním jménem
běh public void run ()Metoda Run provede akci pro vlákno. Vyvolá vlákno.
Start public void start ()Používá se ke spuštění provádění vlákna. Interně metoda JVM volá run () v tomto vlákně.
připojit se public void join ()Počkejte, až nit zemře
veřejné neplatné spojení (dlouhé milisekundy)Počkejte určené milisekundy, než vlákno zemře.
getPriority public int getPriority ()Vrátit prioritu vlákna
setPriority public int setPriority (int priorita)Změňte prioritu vlákna na zadanou prioritu
getName public String getName ()vrátit název vlákna.
setName public void setName (název řetězce)Nastavte název vlákna na zadaný řetězec
currentThread public Thread currentThread ()Vrátí odkaz na vlákno, které je aktuálně aktivní
getId public int getId ()Vrátit ID vlákna
getState () public Thread.State getState ()Vrátí aktuální stav vlákna
je naživu public boolean isAlive ()Zkontrolujte, zda je vlákno naživu, a pokud ano, vraťte true.
výtěžek výnos veřejné neplatnosti ()Dočasně pozastaví aktuální vlákno a umožní spuštění jiným vláknům.
isDaemon public boolean isDaemon ()Zkontrolujte, zda je vlákno daemonovým vláknem; vrátit true, pokud ano.
setDaemon public void setDaemon (boolean b)Nastavit vlákno jako vlákno démona, pokud b = true; jinak nastaveno jako uživatelské vlákno.
přerušit public void interrupt ()Přerušte aktuální vlákno.
je přerušeno public boolean isInterrupted ()Zkontrolujte, zda není vlákno přerušeno.
přerušeno public static boolean přerušeno ()Zkontrolujte, zda nebylo přerušeno aktuální vlákno.
dumpStack Static void dumpStack ()Vytiskne trasování zásobníku aktuálního vlákna do standardního chybového proudu.
pozastavit pozastavení veřejné neplatnosti ()Pozastaví všechna vlákna. (** metoda je v nejnovějších verzích Java zastaralá)
životopis public void resume ()Obnovte zavěšené vlákno. (** metoda je v nejnovějších verzích Java zastaralá)
stop veřejné neplatné zastavení ()Zastaví vlákno. (** metoda je v nejnovějších verzích Java zastaralá)

Tyto metody podprocesů rozvedeme v našem dalším kurzu multithreadingu.

Spuštění vlákna

Metoda start (), která se používá ke spuštění podprocesu, provádí následující kroky:

  • Spustí novou instanci vlákna s novým CallStack.
  • Stav vlákna se změní z nového na spustitelný.
  • Když je na řadě vlákno, provede metodu run ().

Implementace rozhraní „Runnable“

Instanci vlákna lze také vytvořit pomocí rozhraní Runnable. Chcete-li vytvořit instanci vlákna, měla by třída, jejíž objekty by měly být spuštěny vláknem, implementovat rozhraní Runnable.

Rozhraní Runnable má pouze jednu metodu:

public void run () => this method is used to execute the thread.

Příklad třídy vlákna

Nyní si ukážeme vlákno v Javě pomocí třídy vlákna.

//class inherited from 'Thread' class ThreadClassDemo extends Thread { private int number; //class constructor public ThreadClassDemo(int number) { this.number = number; } //run method => execution code for thread public void run() { int counter = 0; int numInt = 0; //prints the number till specified number is reached, starting from 10 do { numInt = (int) (counter + 10); System.out.println(this.getName() + ' prints ' + numInt); counter++; } while(numInt != number); System.out.println('** Correct! ' + this.getName() + 'printed ' + counter + ' times.**'); } } public class Main { public static void main(String () args) { System.out.println('Starting thread_1...'); //create a thread class instance Thread thread_1 = new ThreadClassDemo(15); //start the thread thread_1 thread_1.start(); try { //wait for thread_1 to die thread_1.join(); } catch (InterruptedException e) { System.out.println('Thread interrupted.'); } System.out.println('Starting thread_2...'); Thread thread_2 = new ThreadClassDemo(20); //start thread_2 thread_2.start(); System.out.println('main() is ending...'); } }

Výstup

Příklad třídy vlákna

Vlákno Java pomocí spustitelného rozhraní

Následující příklad ukazuje použití rozhraní Runnable k vytvoření instance vlákna.

//class implements Runnable interface class RunnableDemo implements Runnable { private String message; //class constructor public RunnableDemo(String message) { this.message = message; } //run method public void run() { while(true) { System.out.println(message); } } } public class Main { public static void main(String () args) { //create first thread instance hello Runnable hello = new RunnableDemo('Hello, Greetings!!!'); Thread thread1 = new Thread(hello); thread1.setDaemon(true); //set this thread as daemon thread1.setName('hello'); System.out.println('Starting First thread...'); //start the thread thread1.start(); //create second thread instance bye Runnable bye = new RunnableDemo('Bye for now!!'); Thread thread2 = new Thread(bye); thread2.setPriority(Thread.MIN_PRIORITY); //set priority to min thread2.setDaemon(true); //set as daemon thread System.out.println('Starting goodbye thread...'); //start the thread thread2.start(); System.out.println('main() is ending...'); } }

Výstup

Java Thread pomocí Runnable rozhraní

Jak zastavit vlákno v Javě

Viděli jsme příklady vláken výše. Z těchto příkladů víme, že když metoda spuštění dokončí provádění, vlákno se zastaví nebo se také zastaví kvůli některým výjimkám.

Dřívější verze prostředí Java měly ve třídě Thread metodu stop (), kterou bylo možné použít k přímému zastavení vlákna. Nyní však byla z bezpečnostních důvodů zastaralá. Musíme tedy použít jiné metody, abychom zastavili prováděné vlákno.

Existují dvě metody, které můžeme použít k zastavení vlákna.

  1. Použití těkavé logické proměnné
  2. Používání přerušení.

V této části probereme obě tyto metody zastavení vlákna.

Použití Volatile Boolean proměnné

V této metodě udržujeme logickou proměnnou say flag, abychom vlákno zastavili. Vlákno běží, dokud je logická proměnná nastavena na hodnotu true. V okamžiku, kdy se stane nepravdivou, se vlákno zastaví.

Specialitou této metody je, že deklarujeme booleovskou proměnnou jako „ nestálý „Tak, aby byl vždy čten z hlavní paměti a program jej nemohl ukládat do mezipaměti CPU. Tímto způsobem nebude žádný rozdíl v nastavených a čtených hodnotách.

Níže je uvedena implementace zastavení vlákna pomocí těkavé logické proměnné.

class StopThread extends Thread { private volatile boolean stop_flag = true; //initially set to true public void stopRunning() { stop_flag = false; //set stop_flag to false } @Override public void run() { while (stop_flag) { //keep checking value of stop_flag System.out.println('Thread is running...'); } System.out.println('Thread stopped!!!'); } } public class Main { public static void main(String() args) { //create a thread instance StopThread stop_thread = new StopThread(); //start the thread stop_thread.start(); try { Thread.sleep(10); } catch (InterruptedException e) { e.printStackTrace(); } //call stopRunning() method to stop the thread stop_thread.stopRunning(); } }

Výstup

Použití těkavé logické proměnné

Poznámka: Zde jsme zobrazili pouze část výstupu. Před zastavením může vlákno běžet několik minut. Abychom mohli získat různé výstupy na různých systémech.

Používání přerušení

Zde je vlákno zastaveno pomocí metody interrupt (), jak jsme již diskutovali výše v metodách třídy vláken. Metoda interrupt () nastavuje stav vlákna jako přerušený. Tento stav je předán smyčce while metody run (). Stav přerušení můžeme získat pomocí metody interrupted ().

Následující program ukazuje použití metody interrupt () k zastavení vlákna.

class StopThread extends Thread { @Override public void run() { while (!Thread.interrupted()) { //check for interrupted status System.out.println('Thread is running...'); } System.out.println('Thread stopped!!!'); } } public class Main { public static void main(String() args) { //create a thread instance StopThread stop_thread = new StopThread(); //start the thread stop_thread.start(); try { Thread.sleep(100); } catch (InterruptedException e) { e.printStackTrace(); } //interrupt the thread stop_thread.interrupt(); } }

Výstup

Použití přerušení - výstup

Často kladené otázky

Otázka č. 1) Proč používáme Multithreading v Javě?

Odpovědět: Vícevláknové zpracování umožňuje souběžné nebo současné provádění dvou nebo více vláken v aplikaci. Souběžné spuštění maximalizuje propustnost a také maximálně využívá CPU.

Otázka č. 2) Co je to multithreading? Jaké jsou jeho typy?

Odpovědět: Vícevláknové zpracování znamená provádění více než jednoho vlákna. Toto provedení může být souběžné nebo paralelní. Multithreading má tedy dva typy, tj. Souběžné nebo paralelní.

Otázka č. 3) Co je to multithreading vs. multiprocesing?

Odpovědět: V multithreadingu existuje více vláken pro stejné nebo různé procesy a tato vlákna se spouštějí souběžně, aby se zvýšila výpočetní rychlost systému. V multiprocesingu má systém více než dva procesory a více procesů se spouští současně.

Otázka č. 4) Jaké jsou výhody multithreadingu v Javě?

Odpovědět: Pomocí multithreadingu můžeme spouštět různé části aplikace současně pomocí vláken. Vícevláknové zpracování zvyšuje propustnost systému. Vícevláknové zpracování také maximalizuje využití procesoru, protože CPU neustále používají různá vlákna.

Otázka č. 5) Je multithreading vhodný pro hraní her?

Odpovědět: Ano, zejména pro moderní hry.

Závěr

Jedná se o zavedení multithreadingu. V tomto kurzu jsme diskutovali o souběžnosti a vícevláknovém zpracování v Javě. Diskutovali jsme o vytvoření vlákna s třídou Thread a také s rozhraním Runnable a poskytli jsme vhodné příklady.

Také jsme se podrobně naučili koncepty jednoho vlákna a jeho vytváření. V tomto kurzu byly probrány koncepty podprocesů včetně životního cyklu podprocesu, zastavení podprocesu, typů podprocesů atd.

Také jsme diskutovali o multithreadingu v délce a souběžnosti v Javě. Na konci tohoto kurzu by čtenář měl být schopen snadno pochopit koncepty souběžnosti a multithreadingu a také vlákna v Javě.

=> Dávejte pozor na jednoduchou sérii školení Java zde.

Doporučené čtení

^