TechCodeview

Multithreading a synchronizace jsou považovány za typickou kapitolu programování v jazyce Java. Ve společnostech zabývajících se vývojem her jsou většinou kladeny otázky týkající se multithreadingových rozhovorů. Seznam často kladených otázek Java multithreading a souběžných rozhovorů je uveden níže.

Otázky pro vícevláknové pohovory

1) Co je to multithreading?

Multithreading je proces spouštění více vláken současně. Multithreading se používá k získání multitaskingu. Spotřebovává méně paměti a poskytuje rychlý a efektivní výkon. Jeho hlavní výhody jsou:

• Vlákna sdílejí stejný adresní prostor.
• Vlákno je lehké.
• Náklady na komunikaci mezi procesy jsou nízké.

2) Jaké je vlákno?

Vlákno je lehký podproces. Jedná se o samostatnou cestu provádění, protože každé vlákno běží v jiném rámci zásobníku. Proces může obsahovat více vláken. Vlákna sdílejí prostředky procesu, ale přesto se provádějí nezávisle.

3) Rozdíl mezi procesem a vláknem?

Mezi procesem a vláknem jsou následující rozdíly.

• Program v provádění se nazývá proces, zatímco; Vlákno je podmnožinou procesu
• Procesy jsou nezávislé, zatímco vlákna jsou podmnožinou procesu.
• Proces má různý adresní prostor v paměti, zatímco vlákna obsahují sdílený adresní prostor.
• Přepínání kontextu je rychlejší mezi vlákny ve srovnání s procesy.
• Meziprocesová komunikace je pomalejší a nákladnější než komunikace mezi vlákny.
• Žádná změna v nadřazeném procesu neovlivní podřízený proces, zatímco změny v nadřazeném vláknu mohou ovlivnit podřízené vlákno.

4) Co rozumíte mezivláknovou komunikací?

• Proces komunikace mezi synchronizovanými vlákny se nazývá mezivláknová komunikace.
• Komunikace mezi vlákny se používá k zamezení dotazování vláken v Javě.
• Vlákno je pozastaveno ve své kritické sekci a další vlákno může vstoupit (nebo se uzamknout) do stejné kritické sekce, která má být spuštěna.
• Lze jej získat metodami wait(), notify() a notifyAll().

5) Jaký je účel metody wait() v Javě?

Metodu wait() poskytuje třída Object v Javě. Tato metoda se používá pro mezivláknovou komunikaci v Javě. K pozastavení aktuálního vlákna a čekání, dokud jiné vlákno nezavolá metodu notify() nebo notifyAll() se používá java.lang.Object.wait(). Jeho syntaxe je uvedena níže.

veřejné konečné void wait()

6) Proč musí být metoda wait() volána ze synchronizovaného bloku?

Musíme zavolat metodu čekání, jinak to vyhodí java.lang.IllegalMonitorStateException výjimka. Navíc potřebujeme metodu wait() pro mezivláknovou komunikaci s notify() a notifyAll(). Proto musí být přítomen v synchronizovaném bloku pro správnou a správnou komunikaci.

7) Jaké jsou výhody multithreadingu?

Vícevláknové programování má následující výhody:

• Multithreading umožňuje aplikaci/programu být vždy reaktivní pro vstup, i když již běží s některými úlohami na pozadí
• Vícevláknové zpracování umožňuje rychlejší provádění úloh, protože vlákna se provádějí nezávisle.
• Vícevláknové zpracování poskytuje lepší využití mezipaměti, protože vlákna sdílejí společné paměťové prostředky.
• Multithreading snižuje počet požadovaných serverů, protože jeden server může spustit více vláken najednou.

8) Jaké jsou stavy životního cyklu vlákna?

Vlákno může mít během své životnosti jeden z následujících stavů:

Nový:V tomto stavu je objekt třídy Thread vytvořen pomocí nového operátoru, ale vlákno není aktivní. Vlákno se nespustí, dokud nezavoláme metodu start().Spustitelné:V tomto stavu je vlákno připraveno ke spuštění po volání metody start(). Vlákno však ještě není vybráno plánovačem vláken.Běh:V tomto stavu plánovač vláken vybere vlákno z připraveného stavu a vlákno je spuštěno.Čekání/blokováno:V tomto stavu vlákno neběží, ale stále žije, nebo čeká na dokončení druhého vlákna.Mrtvý/ukončený:Při ukončení metody run() je vlákno v ukončeném nebo mrtvém stavu.

9) Jaký je rozdíl mezi preemptivním plánováním a časovým dělením?

V rámci preemptivního plánování se úloha s nejvyšší prioritou provádí, dokud nepřejde do stavu čekání nebo mrtvých stavů nebo dokud nevznikne úloha s vyšší prioritou. Při časovém dělení se úloha provádí po předem definovaný časový úsek a poté znovu vstoupí do fondu připravených úloh. Plánovač pak určí, která úloha by se měla provést jako další, na základě priority a dalších faktorů.

10) Co je přepínání kontextu?

Při přepínání kontextu je stav procesu (nebo vlákna) uložen tak, aby jej bylo možné obnovit a spustit později od stejného bodu. Přepínání kontextu umožňuje více procesům sdílet stejný CPU.

11) Rozdíl mezi třídou Thread a rozhraním Runnable pro vytvoření vlákna?

Vlákno lze vytvořit dvěma způsoby.

• Rozšířením třídy Thread
• Implementací rozhraní Runnable

Primární rozdíly mezi oběma způsoby jsou však uvedeny níže:

• Rozšířením třídy Thread nemůžeme rozšířit žádnou další třídu, protože Java při implementaci rozhraní Runnable neumožňuje vícenásobné dědění; můžeme také rozšířit další základní třídu (v případě potřeby).
• Rozšířením třídy Thread každé vlákno vytvoří jedinečný objekt a připojí se k němu při implementaci rozhraní Runnable; více vláken sdílí stejný objekt
• Třída Thread poskytuje různé vestavěné metody, jako je getPriority(), isAlive a mnoho dalších, zatímco rozhraní Runnable poskytuje jedinou metodu, tj.

12) Co znamená metoda join()?

Metoda join() čeká, až vlákno zemře. Jinými slovy způsobí, že aktuálně běžící vlákna se zastaví, dokud vlákno, ke kterému se připojí, nedokončí svůj úkol. Metoda spojení je ve třídě Thread přetížena následujícími způsoby.

• public void join() vyvolá InterruptedException
• public void join (dlouhé milisekundy) vyvolá InterruptedException

13) Popište účel a fungování metody sleep().

Metoda sleep() v jazyce Java se používá k zablokování vlákna na určitou dobu, což znamená, že pozastaví provádění vlákna na určitou dobu. Existují dva způsoby, jak toho dosáhnout.

Syntax:

singleton designový vzor java

• public static void sleep (dlouhé milisekundy) vyvolá InterruptedException
• public static void sleep (dlouhé milisekundy, int nanos) vyvolá InterruptedException

Fungování metody sleep().

Když zavoláme metodu sleep(), pozastaví provádění aktuálního vlákna na danou dobu a upřednostní jiné vlákno (pokud je k dispozici). Navíc, když čekací doba skončí, předchozí vlákno opět změní svůj stav z čekání na spustitelné a přejde do stavu běhu a celý proces tak funguje, dokud se provádění nedokončí.

14) Jaký je rozdíl mezi metodou wait() a sleep()?

15) Je možné založit vlákno dvakrát?

Ne, vlákno nemůžeme restartovat, protože jakmile se vlákno spustí a spustí, přejde do stavu mrtvého. Pokud se tedy pokusíme spustit vlákno dvakrát, poskytne runtimeException 'java.lang.IllegalThreadStateException'. Zvažte následující příklad.

 public class Multithread1 extends Thread { public void run() { try { System.out.println('thread is executing now........'); } catch(Exception e) { } } public static void main (String[] args) { Multithread1 m1= new Multithread1(); m1.start(); m1.start(); } } 

Výstup

 thread is executing now........ Exception in thread 'main' java.lang.IllegalThreadStateException at java.lang.Thread.start(Thread.java:708) at Multithread1.main(Multithread1.java:13) 

16) Můžeme místo start() zavolat metodu run()?

Ano, přímé volání metody run() je platné, ale nebude fungovat jako vlákno, místo toho bude fungovat jako normální objekt. Mezi vlákny nebude docházet k přepínání kontextu. Když zavoláme metodu start(), interně zavolá metodu run(), která vytvoří nový zásobník pro vlákno, zatímco přímé volání run() nevytvoří nový zásobník.

17) A co vlákna démonů?

Vlákna démona jsou vlákna s nízkou prioritou, která poskytují podporu a služby na pozadí uživatelským vláknům. Vlákno démona se automaticky ukončí JVM, pokud program zůstane pouze s vláknem démona a všechna ostatní uživatelská vlákna jsou ukončena/ukončena. Ve třídě Thread jsou k dispozici dvě metody pro vlákno démona:

public void setDaemon (logický stav):Používá se k označení vlákna démona vlákna nebo uživatelského vlákna.public boolean isDaemon():Zkontroluje, zda je vlákno démonem nebo ne.

18) Můžeme vytvořit uživatelské vlákno jako vlákno démona, pokud je vlákno spuštěno?

Ne, pokud tak učiníte, vyvolá to výjimku IllegalThreadStateException. Proto můžeme před spuštěním vlákna vytvořit pouze vlákno démona.

linux který

 class Testdaemon1 extends Thread{ public void run(){ System.out.println('Running thread is daemon...'); } public static void main (String[] args) { Testdaemon1 td= new Testdaemon1(); td.start(); setDaemon(true);// It will throw the exception: td. } } 

Výstup

 Running thread is daemon... Exception in thread 'main' java.lang.IllegalThreadStateException at java.lang.Thread.setDaemon(Thread.java:1359) at Testdaemon1.main(Testdaemon1.java:8) 

19) Co je to vypínací hák?

Vypínací hák je vlákno, které je vyvoláno implicitně před vypnutím JVM. Můžeme jej tedy použít k provedení vyčištění zdroje nebo uložení stavu, když se JVM normálně nebo náhle vypne. Vypínací hák můžeme přidat pomocí následující metody:

 public�void�addShutdownHook(Thread�hook){}�� Runtime r=Runtime.getRuntime(); r.addShutdownHook(new MyThread()); 

Některé důležité body týkající se vypínacích háčků jsou:

• Vypínací háky byly inicializovány, ale lze je spustit pouze při vypnutí prostředí JVM.
• Vypínací háky jsou spolehlivější než finalizer(), protože existuje velmi menší pravděpodobnost, že se vypínací háky nespustí.
• Vypínací hák lze zastavit voláním metody halt(int) třídy Runtime.

20) Kdy bychom měli přerušit vlákno?

Vlákno bychom měli přerušit, když chceme přerušit stav spánku nebo čekání vlákna. Vlákno můžeme přerušit voláním interrupt()�vyvoláním InterruptedException.

21) Jaká je synchronizace?

Synchronizace je schopnost řídit přístup více vláken k libovolnému sdílenému prostředku. Používá se:

1. Aby se zabránilo rušení závitu.
2. Aby se předešlo problémům s konzistencí.

Když se více vláken pokouší provést stejnou úlohu, existuje možnost chybného výsledku, a proto k odstranění tohoto problému používá Java proces synchronizace, který umožňuje spuštění pouze jednoho vlákna najednou. Synchronizaci lze dosáhnout třemi způsoby:

• synchronizovanou metodou
• synchronizovaným blokem
• statickou synchronizací

Syntaxe pro synchronizovaný blok

 synchronized(object reference expression) { //code block } 

22) Jaký je účel synchronizovaného bloku?

Blok Synchronized lze použít k provedení synchronizace na libovolném konkrétním zdroji metody. Na konkrétním zdroji může být spuštěno pouze jedno vlákno najednou a všechna ostatní vlákna, která se pokoušejí vstoupit do synchronizovaného bloku, jsou blokována.

• Synchronizovaný blok se používá k uzamčení objektu pro jakýkoli sdílený prostředek.
• Rozsah synchronizovaného bloku je omezen na blok, na který je aplikován. Její rozsah je menší než u metody.

23) Může být objekt Java uzamčen pro výhradní použití daným vláknem?

Ano. Objekt můžete uzamknout tak, že jej vložíte do „synchronizovaného“ bloku. Uzamčený objekt je nepřístupný žádnému jinému vláknu než tomu, které si ho výslovně nárokovalo.

24) Co je statická synchronizace?

Pokud provedete jakoukoli statickou metodu jako synchronizovanou, zámek bude na třídě, nikoli na objektu. Pokud použijeme klíčové slovo synchronized před metodou, tak to objekt uzamkne (jedno vlákno může přistupovat k objektu najednou), ale pokud použijeme static synchronized, tak to zamkne třídu (jedno vlákno může přistupovat ke třídě najednou). Více informací.

25) Jaký je rozdíl mezi notify() a notifyAll()?

Notify() se používá k odblokování jednoho čekajícího vlákna, zatímco metoda notifyAll() se používá k odblokování všech vláken ve stavu čekání.

26) Co je to zablokování?

Zablokování je situace, kdy každé vlákno čeká na zdroj, který je držen jiným čekajícím vláknem. V této situaci se ani jedno vlákno nespustí, ani nezíská příležitost ke spuštění. Místo toho mezi všemi vlákny existuje univerzální stav čekání. Deadlock je velmi komplikovaná situace, která může prolomit náš kód za běhu.

27) Jak zjistit stav uváznutí? Jak se tomu lze vyhnout?

Stav zablokování můžeme zjistit spuštěním kódu na cmd a shromažďováním výpisu vláken, a pokud je v kódu přítomno zablokování, objeví se zpráva na cmd.

Způsoby, jak se vyhnout zablokování v Javě:

Vyhněte se vnořenému zámku:Vnořený zámek je běžným důvodem uváznutí, protože k uváznutí dochází, když poskytujeme zámky různým vláknům, takže bychom měli v určitém čase dát jeden zámek pouze jednomu vláknu.Vyhněte se zbytečným zámkům:musíme se vyhnout zámkům, které nejsou vyžadovány.Použití spojení vláken:Spojení vláken pomáhá čekat na vlákno, dokud jiné vlákno nedokončí své provádění, takže se můžeme vyhnout uváznutí maximálním využitím metody spojení.

28) Co je to Thread Scheduler v Javě?

V Javě, když vytváříme vlákna, jsou pod dohledem pomocí Thread Scheduler, který je součástí JVM. Plánovač vláken je zodpovědný pouze za rozhodnutí, které vlákno by se mělo spustit. Plánovač vláken používá dva mechanismy pro plánování vláken: Preemptive a Time Slicing.

• Vybírá prioritu vlákna.
• Určuje dobu čekání na vlákno
• Kontroluje povahu vlákna

29) Má každé vlákno svůj zásobník ve vícevláknovém programování?

Ano, ve vícevláknovém programování si každé vlákno udržuje svou vlastní nebo samostatnou oblast zásobníku v paměti, díky čemuž je každé vlákno na sobě nezávislé.

30) Jak je dosaženo bezpečnosti závitu?

Pokud metodu nebo objekt třídy může používat více podprocesů najednou bez jakéhokoli sporu, pak je třída bezpečná podprocesy. Zabezpečení vláken se používá k tomu, aby byl program bezpečný pro použití ve vícevláknovém programování. Toho lze dosáhnout následujícími způsoby:

• Synchronizace
• Použití volatilního klíčového slova
• Použití mechanismu založeného na zámku
• Použití atomových obalových tříd

31) Co je to závodní kondice?

Závodní podmínka je problém, který se vyskytuje ve vícevláknovém programování, když různá vlákna provádějí simultánní přístup ke sdílenému prostředku ve stejnou dobu. Správným použitím synchronizace se můžete vyhnout podmínkám závodu.

10 ze 40

32) Co je nestálé klíčové slovo v Javě?

Volatile klíčové slovo se používá ve vícevláknovém programování k dosažení bezpečnosti vlákna, protože změna v jedné nestálé proměnné je viditelná pro všechna ostatní vlákna, takže jednu proměnnou může používat jedno vlákno najednou.

33) Co rozumíte pod pojmem fond vláken?

• Java Thread pool představuje skupinu pracovních vláken, která čekají na přidělení úlohy.
• Vlákna ve fondu vláken jsou pod dohledem poskytovatele služeb, který stáhne jedno vlákno z fondu a přiřadí mu úlohu.
• Po dokončení daného úkolu se vlákno znovu dostalo do fondu vláken.
• Velikost fondu vláken závisí na celkovém počtu vláken udržovaných v rezervě pro spuštění.

Výhody fondu vláken jsou:

• Pomocí fondu vláken lze zvýšit výkon.
• Pomocí fondu vláken může dojít k lepší stabilitě systému.

Otázky k souběžnému pohovoru

34) Jaké jsou hlavní součásti Concurrency API?

Concurrency API lze vyvinout pomocí třídy a rozhraní balíčku java.util.Concurrent. V balíčku java.util.Concurrent jsou následující třídy a rozhraní.

• Vykonavatel
• FarkJoinPool
• ExekutorService
• ScheduledExecutorService
• Budoucnost
• Časová jednotka (výčet)
• CountDownLatch
• CyclicBarrier
• Semafor
• ThreadFactory
• BlockingQueue
• DelayQueue
• Zámky
• Phaser

35) Jaké je rozhraní Executor v Concurrency API v Javě?

Rozhraní Executor poskytované balíčkem java.util.concurrent je jednoduché rozhraní používané k provedení nové úlohy. K provedení určitého příkazu se používá metoda execute() rozhraní Executor. Syntaxe metody execute() je uvedena níže.

void execute (spustitelný příkaz)

Zvažte následující příklad:

 import java.util.concurrent.Executor; import java.util.concurrent.Executors; import java.util.concurrent.ThreadPoolExecutor; import java.util.concurrent.TimeUnit; public class TestThread { public static void main(final String[] arguments) throws InterruptedException { Executor e = Executors.newCachedThreadPool(); e.execute(new Thread()); ThreadPoolExecutor pool = (ThreadPoolExecutor)e; pool.shutdown(); } static class Thread implements Runnable { public void run() { try { Long duration = (long) (Math.random() * 5); System.out.println('Running Thread!'); TimeUnit.SECONDS.sleep(duration); System.out.println('Thread Completed'); } catch (InterruptedException ex) { ex.printStackTrace(); } } } } 

Výstup

 Running Thread! Thread Completed 

36) Co je BlockingQueue?

Java.util.concurrent.BlockingQueue je podrozhraní Queue, které podporuje operace, jako je čekání na dostupnost místa před vložením nové hodnoty nebo čekání, až se fronta vyprázdní, než z ní načte prvek. Zvažte následující příklad.

 import java.util.Random; import java.util.concurrent.ArrayBlockingQueue; import java.util.concurrent.BlockingQueue; public class TestThread { public static void main(final String[] arguments) throws InterruptedException { BlockingQueue queue = new ArrayBlockingQueue(10); Insert i = new Insert(queue); Retrieve r = new Retrieve(queue); new Thread(i).start(); new Thread(r).start(); Thread.sleep(2000); } static class Insert implements Runnable { private BlockingQueue queue; public Insert(BlockingQueue queue) { this.queue = queue; } @Override public void run() { Random random = new Random(); try { int result = random.nextInt(200); Thread.sleep(1000); queue.put(result); System.out.println('Added: ' + result); result = random.nextInt(10); Thread.sleep(1000); queue.put(result); System.out.println('Added: ' + result); result = random.nextInt(50); Thread.sleep(1000); queue.put(result); System.out.println('Added: ' + result); } catch (InterruptedException e) { e.printStackTrace(); } } } static class Retrieve implements Runnable { private BlockingQueue queue; public Retrieve(BlockingQueue queue) { this.queue = queue; } @Override public void run() { try { System.out.println('Removed: ' + queue.take()); System.out.println('Removed: ' + queue.take()); System.out.println('Removed: ' + queue.take()); } catch (InterruptedException e) { e.printStackTrace(); } } } } 

Výstup

 Added: 96 Removed: 96 Added: 8 Removed: 8 Added: 5 Removed: 5 

37) Jak implementovat problém výrobce-spotřebitel pomocí BlockingQueue?

Problém výrobce-spotřebitel lze vyřešit pomocí BlockingQueue následujícím způsobem.

 import java.util.concurrent.BlockingQueue; import java.util.concurrent.LinkedBlockingQueue; import java.util.logging.Level; import java.util.logging.Logger; public class ProducerConsumerProblem { public static void main(String args[]){ //Creating shared object BlockingQueue sharedQueue = new LinkedBlockingQueue(); //Creating Producer and Consumer Thread Thread prod = new Thread(new Producer(sharedQueue)); Thread cons = new Thread(new Consumer(sharedQueue)); //Starting producer and Consumer thread prod.start(); cons.start(); } } //Producer Class in java class Producer implements Runnable { private final BlockingQueue sharedQueue; public Producer(BlockingQueue sharedQueue) { this.sharedQueue = sharedQueue; } @Override public void run() { for(int i=0; i<10; i++){ try { system.out.println('produced: ' + i); sharedqueue.put(i); } catch (interruptedexception ex) logger.getlogger(producer.class.getname()).log(level.severe, null, ex); consumer class in java implements runnable{ private final blockingqueue sharedqueue; public (blockingqueue sharedqueue) this.sharedqueue="sharedQueue;" @override void run() while(true){ system.out.println('consumed: '+ sharedqueue.take()); logger.getlogger(consumer.class.getname()).log(level.severe, < pre> <p> <strong>Output</strong> </p> <pre> Produced: 0 Produced: 1 Produced: 2 Produced: 3 Produced: 4 Produced: 5 Produced: 6 Produced: 7 Produced: 8 Produced: 9 Consumed: 0 Consumed: 1 Consumed: 2 Consumed: 3 Consumed: 4 Consumed: 5 Consumed: 6 Consumed: 7 Consumed: 8 Consumed: 9 </pre> <hr> <h3>38) What is the difference between Java Callable interface and Runnable interface?</h3> <p>The Callable interface and Runnable interface both are used by the classes which wanted to execute with multiple threads. However, there are two main differences between the both : </p> <ul> <li>A Callable interface can return a result, whereas the Runnable interface cannot return any result.</li> <li>A Callable interface can throw a checked exception, whereas the Runnable interface cannot throw checked exception. </li> <li>A Callable interface cannot be used before the Java 5 whereas the Runnable interface can be used.</li> </ul> <hr> <h3>39) What is the Atomic action in Concurrency in Java?</h3> <ul> <li>The Atomic action is the operation which can be performed in a single unit of a task without any interference of the other operations.</li> <li>The Atomic action cannot be stopped in between the task. Once started it fill stop after the completion of the task only. </li> <li>An increment operation such as a++ does not allow an atomic action.</li> <li>All reads and writes operation for the primitive variable (except long and double) are the atomic operation.</li> <li>All reads and writes operation for the volatile variable (including long and double) are the atomic operation.</li> <li>The Atomic methods are available in java.util.Concurrent package. </li> </ul> <hr> <h3>40) What is lock interface in Concurrency API in Java?</h3> <p>The java.util.concurrent.locks.Lock interface is used as the synchronization mechanism. It works similar to the synchronized block. There are a few differences between the lock and synchronized block that are given below.</p> <ul> <li>Lock interface provides the guarantee of sequence in which the waiting thread will be given the access, whereas the synchronized block doesn&apos;t guarantee it.</li> <li>Lock interface provides the option of timeout if the lock is not granted whereas the synchronized block doesn&apos;t provide that.</li> <li>The methods of Lock interface, i.e., Lock() and Unlock() can be called in different methods whereas single synchronized block must be fully contained in a single method.</li> </ul> <hr> <h3>41) Explain the ExecutorService Interface.</h3> <p>The ExecutorService Interface is the subinterface of Executor interface and adds the features to manage the lifecycle. Consider the following example.</p> <pre> import java.util.concurrent.ExecutorService; import java.util.concurrent.Executors; import java.util.concurrent.TimeUnit; public class TestThread { public static void main(final String[] arguments) throws InterruptedException { ExecutorService e = Executors.newSingleThreadExecutor(); try { e.submit(new Thread()); System.out.println(&apos;Shutdown executor&apos;); e.shutdown(); e.awaitTermination(5, TimeUnit.SECONDS); } catch (InterruptedException ex) { System.err.println(&apos;tasks interrupted&apos;); } finally { if (!e.isTerminated()) { System.err.println(&apos;cancel non-finished tasks&apos;); } e.shutdownNow(); System.out.println(&apos;shutdown finished&apos;); } } static class Task implements Runnable { public void run() { try { Long duration = (long) (Math.random() * 20); System.out.println(&apos;Running Task!&apos;); TimeUnit.SECONDS.sleep(duration); } catch (InterruptedException ex) { ex.printStackTrace(); } } } } </pre> <p> <strong>Output</strong> </p> <pre> Shutdown executor shutdown finished </pre> <hr> <h3>42) What is the difference between Synchronous programming and Asynchronous programming regarding a thread?</h3> <p> <strong>Synchronous programming: </strong> In Synchronous programming model, a thread is assigned to complete a task and hence thread started working on it, and it is only available for other tasks once it will end the assigned task.</p> <p> <strong>Asynchronous Programming: </strong> In Asynchronous programming, one job can be completed by multiple threads and hence it provides maximum usability of the various threads.</p> <hr> <h3>43) What do you understand by Callable and Future in Java?</h3> <p> <strong>Java Callable interface: </strong> In Java5 callable interface was provided by the package java.util.concurrent. It is similar to the Runnable interface but it can return a result, and it can throw an Exception. It also provides a run() method for execution of a thread. Java Callable can return any object as it uses Generic.</p> <p> <strong>Syntax:</strong> </p> <p>public interface Callable</p> <p> <strong>Java Future interface:</strong> Java Future interface gives the result of a concurrent process. The Callable interface returns the object of java.util.concurrent.Future.</p> <p>Java Future provides following methods for implementation.</p> <ul> <tr><td>cancel(boolean&#xFFFD;mayInterruptIfRunning):</td> It is used to cancel the execution of the assigned task. </tr><tr><td>get():</td> It waits for the time if execution not completed and then retrieved the result. </tr><tr><td>isCancelled():</td> It returns the Boolean value as it returns true if the task was canceled before the completion. </tr><tr><td>isDone():</td> It returns true if the job is completed successfully else returns false. </tr></ul> <hr> <h3>44. What is the difference between ScheduledExecutorService and ExecutorService interface?</h3> <p>ExecutorServcie and ScheduledExecutorService both are the interfaces of java.util.Concurrent package but scheduledExecutorService provides some additional methods to execute the Runnable and Callable tasks with the delay or every fixed time period.</p> <h3>45) Define FutureTask class in Java? </h3> <p>Java FutureTask class provides a base implementation of the Future interface. The result can only be obtained if the execution of one task is completed, and if the computation is not achieved then get method will be blocked. If the execution is completed, then it cannot be re-started and can&apos;t be canceled.</p> <p> <strong>Syntax</strong> </p> <p>public class FutureTask extends Object implements RunnableFuture</p> <hr></10;>

38) Jaký je rozdíl mezi rozhraním Java Callable a rozhraním Runnable?

Rozhraní Callable a Runnable používají třídy, které chtěly spustit s více vlákny. Mezi oběma jsou však dva hlavní rozdíly:

• Volitelné rozhraní může vrátit výsledek, zatímco rozhraní Runnable nemůže vrátit žádný výsledek.
• Volatelné rozhraní může vyvolat kontrolovanou výjimku, zatímco rozhraní Runnable nemůže vyvolat zaškrtnutou výjimku.
• Rozhraní Callable nelze použít před Java 5, zatímco rozhraní Runnable lze použít.

39) Co je to Atomic action in Concurrency v Javě?

• Atomová akce je operace, kterou lze provést v jedné jednotce úlohy bez jakéhokoli rušení ostatních operací.
• Atomická akce nemůže být zastavena mezi úkolem. Po spuštění se vyplní až po dokončení úkolu.
• Operace zvýšení, jako je a++, neumožňuje atomovou akci.
• Všechny operace čtení a zápisu pro primitivní proměnnou (kromě long a double) jsou atomické operace.
• Všechny operace čtení a zápisu pro těkavou proměnnou (včetně long a double) jsou atomické operace.
• Metody Atomic jsou dostupné v balíčku java.util.Concurrent.

40) Co je rozhraní zámku v Concurrency API v Javě?

Jako mechanismus synchronizace se používá rozhraní java.util.concurrent.locks.Lock. Funguje podobně jako synchronizovaný blok. Mezi zámkem a synchronizovaným blokem je několik rozdílů, které jsou uvedeny níže.

celé číslo na řetězec v jazyce Java

• Rozhraní zámku poskytuje záruku pořadí, ve kterém bude čekajícímu vláknu udělen přístup, zatímco synchronizovaný blok jej nezaručuje.
• Rozhraní zámku poskytuje možnost časového limitu, pokud není zámek udělen, zatímco synchronizovaný blok to neposkytuje.
• Metody rozhraní Lock, tj. Lock() a Unlock() lze volat různými metodami, zatímco jeden synchronizovaný blok musí být plně obsažen v jediné metodě.

41) Vysvětlete rozhraní ExecutorService.

Rozhraní ExecutorService je podrozhraním rozhraní Executor a přidává funkce pro správu životního cyklu. Zvažte následující příklad.

 import java.util.concurrent.ExecutorService; import java.util.concurrent.Executors; import java.util.concurrent.TimeUnit; public class TestThread { public static void main(final String[] arguments) throws InterruptedException { ExecutorService e = Executors.newSingleThreadExecutor(); try { e.submit(new Thread()); System.out.println('Shutdown executor'); e.shutdown(); e.awaitTermination(5, TimeUnit.SECONDS); } catch (InterruptedException ex) { System.err.println('tasks interrupted'); } finally { if (!e.isTerminated()) { System.err.println('cancel non-finished tasks'); } e.shutdownNow(); System.out.println('shutdown finished'); } } static class Task implements Runnable { public void run() { try { Long duration = (long) (Math.random() * 20); System.out.println('Running Task!'); TimeUnit.SECONDS.sleep(duration); } catch (InterruptedException ex) { ex.printStackTrace(); } } } } 

Výstup

 Shutdown executor shutdown finished 

42) Jaký je rozdíl mezi synchronním programováním a asynchronním programováním, pokud jde o vlákno?

Synchronní programování: V synchronním programovacím modelu je vlákno přiřazeno k dokončení úkolu, a proto na něm vlákno začalo pracovat, a pro ostatní úkoly je dostupné až poté, co přiřazený úkol ukončí.

Asynchronní programování: V asynchronním programování může být jedna úloha dokončena více vlákny, a proto poskytuje maximální využitelnost různých vláken.

43) Co rozumíte pod pojmem Callable a Future v Javě?

Java Callable rozhraní: V Java5 bylo volatelné rozhraní poskytnuto balíčkem java.util.concurrent. Je podobné rozhraní Runnable, ale může vrátit výsledek a může vyvolat výjimku. Poskytuje také metodu run() pro spuštění vlákna. Java Callable může vrátit jakýkoli objekt, protože používá Generic.

Syntax:

veřejné rozhraní Volitelné

Rozhraní Java Future: Rozhraní Java Future poskytuje výsledek souběžného procesu. Rozhraní Callable vrací objekt java.util.concurrent.Future.

Java Future poskytuje následující metody implementace.

cancel(boolean�mayInterruptIfRunning):Slouží ke zrušení provedení přiděleného úkolu.dostat():Čeká na čas, pokud provedení není dokončeno, a pak načte výsledek.isCancelled():Vrací logickou hodnotu, protože vrací true, pokud byla úloha zrušena před dokončením.je hotovo():Pokud je úloha úspěšně dokončena, vrátí hodnotu true, jinak vrátí hodnotu false.

44. Jaký je rozdíl mezi rozhraním ScheduledExecutorService a ExecutorService?

ExecutorServcie a ScheduledExecutorService jsou rozhraním balíčku java.util.Concurrent, ale plánovanéExecutorService poskytuje některé další metody pro provádění úloh Runnable a Callable se zpožděním nebo v každém pevném časovém období.

45) Definovat třídu FutureTask v Javě?

Třída Java FutureTask poskytuje základní implementaci rozhraní budoucnosti. Výsledek lze získat pouze v případě, že je dokončeno provedení jedné úlohy, a pokud není výpočet dosažen, bude metoda get zablokována. Pokud je provádění dokončeno, nelze jej znovu spustit a nelze jej zrušit.

Syntax

public class FutureTask rozšiřuje Object implementuje RunnableFuture