A multithreading és a szinkronizálás a java programozás tipikus fejezete. A játékfejlesztő cégeknél többnyire többszálas interjúkérdéseket tesznek fel. Az alábbiakban a gyakran feltett Java többszálú és párhuzamos interjúkérdések listája található.

Többszálú interjúkérdések

1) Mi az a többszálú feldolgozás?

A többszálú feldolgozás több szál egyidejű végrehajtásának folyamata. A multithreading a multitasking eléréséhez használatos. Kevesebb memóriát fogyaszt, és gyors és hatékony teljesítményt nyújt. Fő előnyei a következők:

• A szálak ugyanazt a címteret használják.
• A cérna könnyű.
• A folyamatok közötti kommunikáció költsége alacsony.

2) Mi a fonal?

A szál egy könnyű részfolyamat. Ez egy külön végrehajtási útvonal, mert minden szál más verem keretben fut. Egy folyamat több szálat is tartalmazhat. A szálak megosztják a folyamaterőforrásokat, de mégis önállóan hajtanak végre.

3) Különbséget tesz a folyamat és a szál között?

A folyamat és a szál között a következő különbségek vannak.

• A végrehajtásban lévő programot folyamatnak nevezzük, míg; A szál a folyamat egy részhalmaza
• A folyamatok függetlenek, míg a szálak a folyamat részhalmazai.
• A folyamatok különböző címterülettel rendelkeznek a memóriában, míg a szálak megosztott címteret tartalmaznak.
• A kontextusváltás gyorsabb a szálak között a folyamatokhoz képest.
• A folyamatok közötti kommunikáció lassabb és drágább, mint a szálak közötti kommunikáció.
• A szülőfolyamat bármilyen változása nem érinti a gyermekfolyamatot, míg a szülő szál változásai hatással lehetnek a gyermekszálra.

4) Mit értesz szálak közötti kommunikáció alatt?

• A szinkronizált szálak közötti kommunikáció folyamatát szálak közötti kommunikációnak nevezik.
• A szálak közötti kommunikációt a Java szál lekérdezésének elkerülésére használják.
• A szál futása a kritikus szakaszában szünetel, és egy másik szál beléphet (vagy zárolható) ugyanabba a kritikus szakaszba, hogy végre lehessen hajtani.
• Megszerezhető a wait(), notify() és notifyAll() metódusokkal.

5) Mi a célja a wait() metódusnak a Java-ban?

A wait() metódust a Java Object osztálya biztosítja. Ezt a módszert a Java szálak közötti kommunikációhoz használják. A java.lang.Object.wait() az aktuális szál szüneteltetésére szolgál, és várja meg, amíg egy másik szál nem hívja meg a notify() vagy notifyAll() metódust. Szintaxisa alább látható.

nyilvános végleges érvénytelen várakozás()

6) Miért kell a wait() metódust meghívni a szinkronizált blokkból?

Meg kell hívnunk a várakozási metódust, különben dobni fog java.lang.IllegalMonitorStateException kivétel. Ezenkívül a wat() metódusra van szükségünk a szálak közötti kommunikációhoz a notify() és notifyAll() függvényekkel. Ezért a megfelelő és helyes kommunikációhoz jelen kell lennie a szinkronizált blokkban.

7) Melyek a többszálú feldolgozás előnyei?

A többszálú programozásnak a következő előnyei vannak:

• A többszálú megoldás lehetővé teszi, hogy egy alkalmazás/program mindig reaktív legyen a bevitelre, még akkor is, ha már fut néhány háttérfeladattal
• A multithreading lehetővé teszi a feladatok gyorsabb végrehajtását, mivel a szálak egymástól függetlenül futnak.
• A többszálú megoldás a gyorsítótár-memória jobb kihasználását teszi lehetővé, mivel a szálak megosztják a közös memória-erőforrásokat.
• A többszálú kezelés csökkenti a szükséges szerverek számát, mivel egy szerver egyszerre több szálat is futtathat.

8) Milyen állapotok vannak a szál életciklusában?

Egy szál élete során a következő állapotok egyikével rendelkezhet:

Új:Ebben az állapotban egy Thread osztály objektum jön létre egy új operátor segítségével, de a szál nem él. A szál addig nem indul el, amíg meg nem hívjuk a start() metódust.Futtatható:Ebben az állapotban a szál a start() metódus meghívása után készen áll a futásra. A szálat azonban még nem választotta ki a szálütemező.Futás:Ebben az állapotban a szálütemező kiválasztja a szálat a kész állapotból, és a szál fut.Várakozás/letiltva:Ebben az állapotban egy szál nem fut, de még él, vagy a másik szál befejezésére vár.Meghalt/megszűnt:A szál lezárt vagy halott állapotban van, amikor a run() metódus kilép.

9) Mi a különbség a megelőző ütemezés és az időszeletelés között?

Preemptív ütemezés esetén a legmagasabb prioritású feladat addig fut, amíg a várakozó vagy holt állapotba nem kerül, vagy egy magasabb prioritású feladat nem jön létre. Az időszeletelés során egy feladat egy előre meghatározott ideig fut, majd újra belép a kész feladatok készletébe. Az ütemező ezután a prioritás és egyéb tényezők alapján meghatározza, hogy melyik feladatot kell végrehajtani legközelebb.

10) Mi az a kontextusváltás?

A kontextusváltásban a folyamat (vagy szál) állapota eltárolásra kerül, így visszaállítható, és a végrehajtás ugyanattól a ponttól később folytatható. A kontextusváltás lehetővé teszi, hogy több folyamat ugyanazon a CPU-n osztozzon.

11) Különbséget tesz a Thread osztály és a Runnable interfész között a szál létrehozásához?

A szál kétféleképpen hozható létre.

• A Thread osztály kiterjesztésével
• A Runnable felület megvalósításával

Az alábbiakban azonban bemutatjuk a két mód közötti elsődleges különbségeket:

• A Thread osztály kiterjesztésével nem tudunk más osztályt kiterjeszteni, mivel a Java nem engedélyez többszörös öröklődést a Runnable felület megvalósítása során; más alaposztályt is kiterjeszthetünk (ha szükséges).
• A Thread osztály kiterjesztésével minden szál létrehozza az egyedi objektumot, és társítja azt a Runnable interfész megvalósítása során; több szál osztozik ugyanazon az objektumon
• A Thread osztály különféle beépített metódusokat biztosít, például a getPriority(), isAlive és még sok mást, míg a Runnable felület egyetlen metódust biztosít, azaz a run().

12) Mit jelent a join() metódus?

A join() metódus megvárja, amíg egy szál elhal. Más szavakkal, az éppen futó szálak végrehajtása leáll, amíg a szál, amelyhez csatlakozik, be nem fejezi a feladatát. A Join metódus a következő módokon túlterhelt a Thread osztályban.

• public void join() dobja: InterruptedException
• public void csatlakozás (hosszú ezredmásodperc) dob InterruptedException

13) Ismertesse az alvás() módszer célját és működését!

A java sleep() metódusa egy szál adott ideig való blokkolására szolgál, ami azt jelenti, hogy egy adott időre szünetelteti a szál végrehajtását. Ennek két módja van.

Szintaxis:

java pont

• nyilvános statikus üres alvás (hosszú ezredmásodperc) dob InterruptedException
• publikus static void alvás (hosszú ezredmásodperc, int nano) dobok InterruptedException

Az alvás() módszer alkalmazása

Amikor meghívjuk a sleep() metódust, az adott ideig szünetelteti az aktuális szál végrehajtását, és elsőbbséget ad egy másik szálnak (ha elérhető). Sőt, amikor a várakozási idő letelt, akkor az előző szál ismét megváltoztatja állapotát várakozásról futtathatóra, és futó állapotba kerül, és az egész folyamat addig működik, amíg a végrehajtás be nem fejeződik.

14) Mi a különbség a wait() és a sleep() metódus között?

15) Lehet-e kétszer indítani egy szálat?

Nem, nem tudjuk újraindítani a szálat, mivel a szál elindítása és végrehajtása után Halott állapotba kerül. Ezért, ha egy szálat kétszer próbálunk meg elindítani, az a 'java.lang.IllegalThreadStateException' runtimeException-t ad. Tekintsük a következő példát.

 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(); } } 

Kimenet

 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) Meghívhatjuk a run() metódust a start() helyett?

Igen, a run() metódus közvetlen hívása érvényes, de nem fog szálként működni, hanem normál objektumként fog működni. Nem lesz kontextusváltás a szálak között. Amikor meghívjuk a start() metódust, akkor az belsőleg meghívja a run() metódust, amely új veremet hoz létre egy szálhoz, miközben a run() közvetlen meghívása nem hoz létre új veremet.

nem null a js-ben

17) Mi a helyzet a démonszálakkal?

A démonszálak alacsony prioritású szálak, amelyek háttértámogatást és szolgáltatásokat biztosítanak a felhasználói szálak számára. A démonszálat a JVM automatikusan leállítja, ha a program csak a démonszálnál marad, és az összes többi felhasználói szál véget ér/elhal. Két módszer áll rendelkezésre a démonszálhoz a Thread osztályban:

public void setDaemon(boolean állapot):A szál démon szál vagy felhasználói szál jelölésére szolgál.publikus logikai isDaemon():Ellenőrzi, hogy a szál démon-e vagy sem.

18) Tehetjük a felhasználói szálat démonszálnak, ha a szál elindul?

Nem, ha így tesz, az IllegalThreadStateException kivételt fog dobni. Ezért csak a szál indítása előtt tudunk démonszálat létrehozni.

 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. } } 

Kimenet

 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) Mi az a shutdown hook?

A shutdown hook egy olyan szál, amely implicit módon a JVM leállása előtt kerül meghívásra. Így használhatjuk az erőforrás tisztítására vagy az állapot mentésére, amikor a JVM rendesen vagy hirtelen leáll. A leállítási horgot a következő módszerrel adhatjuk hozzá:

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

Néhány fontos pont a leállítási horgokkal kapcsolatban:

• A leállítási horgok inicializálva, de csak akkor indíthatók el, amikor a JVM leállt.
• A leállítási horgok megbízhatóbbak, mint a finalizer(), mert nagyon kisebb az esélye annak, hogy a leállítási horgok nem futnak.
• A shutdown hook leállítható a Runtime osztály halt(int) metódusának meghívásával.

20) Mikor szakítsunk meg egy szálat?

Meg kell szakítanunk egy szálat, ha meg akarjuk szakítani egy szál alvó vagy várakozási állapotát. Megszakíthatunk egy szálat az interrupt() meghívásával, az InterruptedException eldobásával.

21) Mi a szinkronizálás?

A szinkronizálás lehetővé teszi több szál hozzáférését bármely megosztott erőforráshoz. Használt:

1. A szál interferencia elkerülése érdekében.
2. A konzisztencia problémájának megelőzése érdekében.

Amikor a több szál megpróbálja végrehajtani ugyanazt a feladatot, fennáll a hibás eredmény lehetősége, ezért a probléma eltávolításához a Java szinkronizálási folyamatot használ, amely egyszerre csak egy szál végrehajtását teszi lehetővé. A szinkronizálást háromféleképpen lehet elérni:

• szinkronizált módszerrel
• szinkronizált blokkal
• statikus szinkronizálással

Szinkronizált blokk szintaxisa

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

22) Mi a Szinkronizált blokk célja?

A szinkronizált blokk a metódus bármely meghatározott erőforrásán szinkronizálásra használható. Egy adott erőforráson egyszerre csak egy szál futhat, és az összes többi szál, amely megpróbál belépni a szinkronizált blokkba, blokkolva van.

• A szinkronizált blokk egy objektum zárolására szolgál bármely megosztott erőforráshoz.
• A szinkronizált blokk hatóköre arra a blokkra korlátozódik, amelyre alkalmazzák. Hatásköre kisebb, mint egy módszeré.

23) Lezárható egy Java objektum egy adott szál kizárólagos használatára?

Igen. Egy objektumot zárolhat úgy, hogy egy „szinkronizált” blokkba helyezi. A zárolt objektum nem érhető el más szálak számára, mint az, amelyik kifejezetten igényelte.

24) Mi a statikus szinkronizálás?

Ha bármilyen statikus metódust szinkronizáltként állít be, a zár az osztályon lesz, nem az objektumon. Ha a szinkronizált kulcsszót használjuk egy metódus előtt, akkor az zárolja az objektumot (egy szál egyszerre fér hozzá az objektumhoz), de ha statikus szinkronizálást használunk, akkor zárol egy osztályt (egy szál egyszerre érhet el egy osztályt). További részletek.

25) Mi a különbség a notify() és a notifyAll() között?

A notify() egy várakozó szál blokkolásának feloldására szolgál, míg a notifyAll() metódus az összes várakozó szál blokkolásának feloldására szolgál.

26) Mi a holtpont?

A holtpont egy olyan helyzet, amelyben minden szál egy erőforrásra vár, amelyet egy másik várakozó szál tart. Ebben a helyzetben egyik szál sem hajtódik végre, és nem kap lehetőséget a végrehajtásra. Ehelyett létezik egy univerzális várakozási állapot az összes szál között. A holtpont egy nagyon bonyolult helyzet, amely futás közben feltörheti a kódunkat.

27) Hogyan lehet észlelni a holtpontot? Hogyan lehet elkerülni?

A holtpontot úgy tudjuk észlelni, hogy futtatjuk a kódot a cmd-n, és összegyűjtjük a Thread Dump-ot, és ha holtpont van a kódban, akkor egy üzenet jelenik meg a cmd-n.

A Java holtpontjának elkerülésének módjai:

Kerülje el a beágyazott zárat:A beágyazott zár a holtpont gyakori oka, mivel a holtpont akkor fordul elő, amikor különböző szálakat biztosítunk, így egy adott időpontban csak egy szálnak kell egy zárolást megadnunk.Kerülje a szükségtelen zárakat:kerülnünk kell a nem szükséges zárakat.Szálak összekapcsolása:A szál összekapcsolása segít megvárni a szálat, amíg egy másik szál be nem fejezi a végrehajtását, így elkerülhetjük a holtpontot az összekapcsolási módszer maximális használatával.

28) Mi az a szálütemező a java-ban?

A Java-ban, amikor létrehozzuk a szálakat, egy szálütemező segítségével felügyeljük őket, amely a JVM része. A szálütemező csak annak eldöntéséért felelős, hogy melyik szálat kell végrehajtani. A szálütemező két mechanizmust használ a szálak ütemezésére: a megelőző és az időszeletelést.

• Kiválasztja a szál prioritását.
• Meghatározza a szál várakozási idejét
• Ellenőrzi a szál természetét

29) Minden szálnak megvan a maga verem a többszálú programozásban?

Igen, a többszálú programozásban minden szál saját vagy külön veremterületet tart fenn a memóriában, aminek köszönhetően minden szál független egymástól.

30) Hogyan érhető el a szál biztonsága?

Ha egy metódust vagy osztályobjektumot egyszerre több szál is használhat versenyfeltételek nélkül, akkor az osztály szálbiztos. A szálbiztonságot arra használják, hogy biztonságossá tegye a programot a többszálú programozásban. A következő módokon érhető el:

• Szinkronizálás
• Volatile kulcsszó használata
• Zár alapú mechanizmus használata
• Atomburkoló osztályok használata

31) Mi az a faji állapot?

A Race feltétel egy olyan probléma, amely a többszálú programozásban jelentkezik, amikor különböző szálak egyidejűleg futnak, és egyszerre érnek el egy megosztott erőforrást. A szinkronizálás megfelelő használatával elkerülhető a Race állapot.

32) Mi az a volatile kulcsszó a java-ban?

A volatile kulcsszót a többszálú programozásban használják a szál biztonságának elérése érdekében, mivel az egyik illékony változó változása az összes többi szál számára látható, így egy változót egyszerre csak egy szál használhat.

33) Mit értesz szálkészlet alatt?

• A Java szálkészlet a munkaszálak egy csoportját képviseli, amelyek a feladat kiosztására várnak.
• A szálkészletben lévő szálakat a szolgáltató felügyeli, amely kihúz egy szálat a készletből, és feladatot rendel hozzá.
• Az adott feladat elvégzése után ismét szál került a szálkészletbe.
• A szálkészlet mérete a végrehajtáshoz tartalékban tartott szálak teljes számától függ.

A szál medence előnyei a következők:

• A szálkészlet használatával a teljesítmény fokozható.
• A szálkészlet használatával jobb rendszerstabilitás érhető el.

Egyidejű interjúkérdések

34) Melyek a párhuzamossági API fő összetevői?

A Concurrency API a java.util.Concurrent csomag osztályával és interfészeivel fejleszthető. A java.util.Concurrent csomagban a következő osztályok és felületek találhatók.

• Végrehajtó
• FarkJoinPool
• VégrehajtóSzolgálat
• ScheduledExecutorService
• Jövő
• Időegység (Enum)
• CountDownLatch
• CyclicBarrier
• Szemafor
• ThreadFactory
• BlockingQueue
• DelayQueue
• Zárak
• Phaser

35) Mi az Executor felület a Concurrency API-ban Java nyelven?

A java.util.concurrent csomag által biztosított végrehajtói felület az új feladat végrehajtásához használt egyszerű felület. Az Executor felület execute() metódusa bizonyos parancsok végrehajtására szolgál. Az execute() metódus szintaxisa alább látható.

void execute (futtatható parancs)

különbség a tömb és a tömblista között

Tekintsük a következő példát:

 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(); } } } } 

Kimenet

 Running Thread! Thread Completed 

36) Mi az a BlockingQueue?

A java.util.concurrent.BlockingQueue a Queue azon alinterfésze, amely támogatja az olyan műveleteket, mint például az új érték beszúrása előtti várakozás a hely rendelkezésre állására, vagy a várakozás, hogy a sor üressé váljon, mielőtt egy elemet lekérne belőle. Tekintsük a következő példát.

 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(); } } } } 

Kimenet

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

37) Hogyan lehet megvalósítani a termelő-fogyasztó problémát a BlockingQueue használatával?

A termelő-fogyasztó probléma a következő módon oldható meg a BlockingQueue használatával.

 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) Mi a különbség a Java hívható felület és a futtatható felület között?

A hívható felületet és a futtatható felületet is azok az osztályok használják, amelyek több szálon akartak végrehajtani. Két fő különbség van azonban a kettő között:

• A hívható interfész visszaadhat eredményt, míg a futtatható felület nem ad vissza eredményt.
• A hívható felület ellenőrzött kivételt tud dobni, míg a futtatható felület nem tud ellenőrzött kivételt.
• A hívható felület nem használható a Java 5 előtt, míg a futtatható felület használható.

39) Mi az Atomic művelet a Concurrency programban Java-ban?

• Az atomművelet az a művelet, amely a feladat egyetlen egységében hajtható végre anélkül, hogy a többi műveletet zavarná.
• Az Atomic műveletet nem lehet leállítani a feladatok között. Az indítás után csak a feladat befejezése után áll le.
• Egy növekményes művelet, például az a++, nem tesz lehetővé atomi műveletet.
• A primitív változó összes olvasási és írási művelete (kivéve a long és a double) az atomi művelet.
• Az illékony változó összes olvasási és írási művelete (beleértve a long és a double) atomi művelet.
• Az Atomic metódusok a java.util.Concurrent csomagban érhetők el.

40) Mi az a zárfelület a Concurrency API-ban a Java nyelven?

A java.util.concurrent.locks.Lock interfész a szinkronizálási mechanizmus. A szinkronizált blokkhoz hasonlóan működik. Van néhány különbség a zár és a szinkronizált blokk között, amelyeket alább ismertetünk.

• A zárolási felület garantálja a sorrendet, amelyben a várakozó szál hozzáférést kap, míg a szinkronizált blokk nem garantálja ezt.
• A zárolási felület lehetőséget biztosít az időtúllépésre, ha a zárolást nem engedélyezik, míg a szinkronizált blokk ezt nem.
• A Lock interfész metódusai, azaz a Lock() és Unlock() különböző metódusokban hívhatók meg, míg az egyetlen szinkronizált blokkot teljes mértékben egyetlen metódusban kell tartalmaznia.

41) Magyarázza el az ExecutorService felületet.

Az ExecutorService Interface az Executor felület alinterfésze, és az életciklus kezeléséhez szükséges szolgáltatásokat ad hozzá. Tekintsük a következő példát.

 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(); } } } } 

Kimenet

 Shutdown executor shutdown finished 

42) Mi a különbség a szinkron programozás és az aszinkron programozás között egy szál tekintetében?

Szinkron programozás: A szinkron programozási modellben egy szál hozzá van rendelve egy feladat elvégzéséhez, így a szál elkezdett dolgozni rajta, és csak akkor érhető el más feladatokhoz, ha befejezi a hozzárendelt feladatot.

Aszinkron programozás: Az aszinkron programozásban egy feladatot több szál is végrehajthat, így a különböző szálak maximális használhatóságát biztosítja.

43) Mit értesz a Callable és Future alatt Java-ban?

Java hívható felület: Java5-ben a hívható felületet a java.util.concurrent csomag biztosította. Hasonló a Runnable felülethez, de visszaadhat eredményt, és kivételt is adhat. Ezenkívül egy run() metódust is biztosít egy szál végrehajtásához. A Java Callable bármilyen objektumot visszaadhat, mivel Generict használ.

mysql egyedi kulcs

Szintaxis:

nyilvános felület Hívható

Java Future felület: A Java Future interfész egy párhuzamos folyamat eredményét adja meg. A Callable felület a java.util.concurrent.Future objektumát adja vissza.

A Java Future a következő módszereket kínálja a megvalósításhoz.

cancel(boolean�mayInterruptIfRunning):A hozzárendelt feladat végrehajtásának megszakítására szolgál.kap():Megvárja az időt, ha a végrehajtás nem fejeződött be, majd lekéri az eredményt.törölve():A logikai értéket adja vissza, mivel igazat ad vissza, ha a feladatot a befejezés előtt törölték.kész():Igazat ad vissza, ha a feladat sikeresen befejeződött, ellenkező esetben hamis értéket ad vissza.

44. Mi a különbség a ScheduledExecutorService és az ExecutorService felület között?

Az ExecutorServcie és a ScheduledExecutorService egyaránt a java.util.Concurrent csomag interfészei, de a scheduledExecutorService további módszereket biztosít a Futható és a Hívható feladatok késleltetéssel vagy minden rögzített időszakonkénti végrehajtására.

45) Definiálja a FutureTask osztályt Java-ban?

A Java FutureTask osztály a Future interfész alap megvalósítását biztosítja. Az eredmény csak akkor érhető el, ha egy feladat végrehajtása befejeződött, és ha a számítás nem teljesül, akkor a get metódus blokkolva lesz. Ha a végrehajtás befejeződött, akkor nem lehet újraindítani és nem lehet megszakítani.

Szintaxis

public class A FutureTask kiterjeszti az Object valósítja meg a RunnableFuture-t