El multithreading i la sincronització es consideren el capítol típic de la programació java. A les empreses de desenvolupament de jocs, les preguntes d'entrevistes relacionades amb el multithreading es fan principalment. A continuació s'ofereix una llista de preguntes freqüents sobre multithreading java i entrevistes de concurrència.
Preguntes d'entrevista multifils
1) Què és el multithreading?
El multithreading és un procés d'execució de diversos fils simultàniament. El multithreading s'utilitza per obtenir la multitasca. Consumeix menys memòria i ofereix un rendiment ràpid i eficient. Els seus principals avantatges són:
- Els fils comparteixen el mateix espai d'adreces.
- El fil és lleuger.
- El cost de la comunicació entre els processos és baix.
2) Quin és el fil?
Un fil és un subprocés lleuger. És un camí d'execució independent perquè cada fil s'executa en un marc de pila diferent. Un procés pot contenir diversos fils. Els fils comparteixen els recursos del procés, però tot i així s'executen de manera independent.
Més detalls.3) Diferenciar entre procés i fil?
Hi ha les següents diferències entre el procés i el fil.
- Un programa en execució s'anomena procés mentre que; Un fil és un subconjunt del procés
- Els processos són independents mentre que els fils són el subconjunt del procés.
- El procés té un espai d'adreces diferent a la memòria, mentre que els fils contenen un espai d'adreces compartit.
- El canvi de context és més ràpid entre els fils en comparació amb els processos.
- La comunicació entre processos és més lenta i cara que la comunicació entre fils.
- Qualsevol canvi en el procés principal no afecta el procés secundari, mentre que els canvis en el fil principal poden afectar el fil secundari.
4) Què entens per comunicació entre fils?
- El procés de comunicació entre fils sincronitzats s'anomena comunicació entre fils.
- La comunicació entre fils s'utilitza per evitar l'enquesta de fils a Java.
- El fil es posa en pausa en execució a la seva secció crítica i un altre fil pot entrar (o bloquejar) a la mateixa secció crítica que s'executa.
- Es pot obtenir mitjançant els mètodes wait(), notify() i notifyAll().
5) Quin és l'objectiu del mètode wait() a Java?
El mètode wait() el proporciona la classe Object a Java. Aquest mètode s'utilitza per a la comunicació entre fils a Java. El java.lang.Object.wait() s'utilitza per aturar el fil actual i esperar fins que un altre fil no cridi el mètode notify() o notifyAll(). La seva sintaxi es mostra a continuació.
espera pública final nul ()
6) Per què s'ha de cridar el mètode wait() des del bloc sincronitzat?
Hem de trucar al mètode d'espera en cas contrari es llançarà java.lang.IllegalMonitorStateException excepció. A més, necessitem el mètode wait() per a la comunicació entre fils amb notify() i notifyAll(). Per tant, ha d'estar present en el bloc sincronitzat per a la correcta i correcta comunicació.
7) Quins són els avantatges del multithreading?
La programació multithreading té els següents avantatges:
- El multithreading permet que una aplicació/programa sigui sempre reactiva per a l'entrada, fins i tot ja s'està executant amb algunes tasques en segon pla
- El multithreading permet una execució més ràpida de les tasques, ja que els fils s'executen de manera independent.
- El multithreading proporciona una millor utilització de la memòria cau, ja que els fils comparteixen els recursos de memòria comuns.
- El multithreading redueix el nombre del servidor necessari, ja que un servidor pot executar diversos fils alhora.
8) Quins són els estats en el cicle de vida d'un fil?
Un fil pot tenir un dels estats següents durant la seva vida útil:
9) Quina diferència hi ha entre la programació preventiva i el tall de temps?
Sota la programació preventiva, la tasca de prioritat més alta s'executa fins que entra als estats d'espera o mort o arriba a existir una tasca de prioritat més alta. Amb el tall de temps, una tasca s'executa durant un període de temps predefinit i després torna a entrar al conjunt de tasques preparades. Aleshores, el planificador determina quina tasca s'ha d'executar a continuació, en funció de la prioritat i d'altres factors.
10) Què és el canvi de context?
En el canvi de context, s'emmagatzema l'estat del procés (o fil) perquè es pugui restaurar i l'execució es pugui reprendre des del mateix punt més tard. El canvi de context permet que diversos processos comparteixin la mateixa CPU.
11) Diferenciar entre la classe Thread i la interfície Runnable per crear un Thread?
El fil es pot crear de dues maneres.
- Ampliant la classe Thread
- Mitjançant la implementació de la interfície Runnable
Tanmateix, les diferències principals entre ambdues maneres es donen a continuació:
- En estendre la classe Thread, no podem ampliar cap altra classe, ja que Java no permet múltiples herències mentre implementem la interfície Runnable; també podem ampliar una altra classe base (si cal).
- En estendre la classe Thread, cadascun dels threads crea l'objecte únic i s'associa amb ell mentre implementa la interfície Runnable; diversos fils comparteixen el mateix objecte
- La classe Thread proporciona diversos mètodes integrats, com ara getPriority(), isAlive i molts més, mentre que la interfície Runnable proporciona un únic mètode, és a dir, run().
12) Què significa el mètode join()?
El mètode join() espera que un fil mor. En altres paraules, fa que els fils que s'executen actualment deixin d'executar-se fins que el fil amb el qual s'uneix completa la seva tasca. El mètode Join es sobrecarrega a la classe Thread de les maneres següents.
- public void join() llança InterruptedException
- public void join (mil·lisegons llargs) llança InterruptedException
13) Descriu el propòsit i el funcionament del mètode sleep().
El mètode sleep() a Java s'utilitza per bloquejar un fil durant un temps determinat, el que significa que posa en pausa l'execució d'un fil durant un temps específic. Hi ha dos mètodes per fer-ho.
Sintaxi:
l'actriu índia rani mukerji
- El repòs public static void (mil·lisegons llargs) genera InterruptedException
- El repòs public static void (mil·lisegons llargs, int nanos) genera InterruptedException
Funcionament del mètode sleep().
mides de lletra de làtex
Quan anomenem el mètode sleep(), atura l'execució del fil actual durant el temps donat i dóna prioritat a un altre fil (si està disponible). A més, quan s'ha completat el temps d'espera, el fil anterior torna a canviar el seu estat d'espera a executable i passa a l'estat d'execució, i tot el procés funciona així fins que l'execució no es completa.
14) Quina diferència hi ha entre el mètode wait() i sleep()?
| espera () | dormir () |
|---|---|
| 1) El mètode wait() es defineix a la classe Object. | El mètode sleep() es defineix a la classe Thread. |
| 2) El mètode wait() allibera el bloqueig. | El mètode sleep() no allibera el bloqueig. |
15) És possible iniciar un fil dues vegades?
No, no podem reiniciar el fil, ja que un cop iniciat i executat, passa a l'estat Mort. Per tant, si intentem iniciar un fil dues vegades, donarà una runtimeException 'java.lang.IllegalThreadStateException'. Considereu l'exemple següent.
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(); } } Sortida
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)Més detalls.
16) Podem cridar el mètode run() en lloc de start()?
Sí, cridar directament al mètode run() és vàlid, però no funcionarà com a fil sinó que funcionarà com a objecte normal. No hi haurà canvi de context entre els fils. Quan cridem al mètode start(), crida internament al mètode run(), que crea una nova pila per a un fil mentre crida directament a run() no crearà una nova pila.
Més detalls.17) Què passa amb els fils del dimoni?
Els fils del dimoni són els fils de baixa prioritat que proporcionen suport i serveis en segon pla als fils d'usuari. La JVM finalitza automàticament el fil del dimoni si el programa només es manté amb el fil del dimoni, i tots els altres fils d'usuari s'acaben o moren. Hi ha dos mètodes per al fil del dimoni disponibles a la classe Thread:
18) Podem convertir el fil d'usuari com a fil de dimoni si s'inicia el fil?
No, si ho feu, llançarà IllegalThreadStateException. Per tant, només podem crear un fil de dimoni abans d'iniciar el fil.
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. } } Sortida
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)Més detalls.
19) Què és el ganxo d'apagada?
El ganxo de tancament és un fil que s'invoca implícitament abans que la JVM s'apaga. Així que podem utilitzar-lo per netejar el recurs o desar l'estat quan la JVM s'apaga amb normalitat o bruscament. Podem afegir un ganxo d'apagada utilitzant el següent mètode:
public�void�addShutdownHook(Thread�hook){}�� Runtime r=Runtime.getRuntime(); r.addShutdownHook(new MyThread()); Alguns punts importants sobre els ganxos de tancament són:
- Els ganxos de tancament s'han inicialitzat, però només es poden iniciar quan s'ha produït l'aturada de la JVM.
- Els ganxos d'apagada són més fiables que el finalitzador() perquè hi ha molt menys possibilitats que els ganxos d'apagada no s'executin.
- El ganxo d'apagada es pot aturar cridant al mètode halt(int) de la classe Runtime.
20) Quan hem d'interrompre un fil?
Hauríem d'interrompre un fil quan volem trencar l'estat de son o espera d'un fil. Podem interrompre un fil cridant a interrupció () � llançant l'Exception Interrupted.
Més detalls.21) Què és la sincronització?
La sincronització és la capacitat de controlar l'accés de diversos fils a qualsevol recurs compartit. S'utilitza:
- Per evitar interferències de fil.
- Per evitar problemes de coherència.
Quan els diversos fils intenten fer la mateixa tasca, hi ha la possibilitat d'un resultat erroni, per tant, per eliminar aquest problema, Java utilitza el procés de sincronització que permet que només s'executi un fil alhora. La sincronització es pot aconseguir de tres maneres:
- pel mètode sincronitzat
- per bloc sincronitzat
- per sincronització estàtica
Sintaxi per al bloc sincronitzat
synchronized(object reference expression) { //code block } Més detalls.22) Quin és l'objectiu del bloc Sincronitzat?
El bloc Sincronitzat es pot utilitzar per realitzar la sincronització en qualsevol recurs específic del mètode. Només un fil a la vegada es pot executar en un recurs concret, i tots els altres fils que intenten entrar al bloc sincronitzat estan bloquejats.
- El bloc sincronitzat s'utilitza per bloquejar un objecte per a qualsevol recurs compartit.
- L'abast del bloc sincronitzat es limita al bloc sobre el qual s'aplica. El seu abast és més petit que un mètode.
23) Es pot bloquejar l'objecte Java per a l'ús exclusiu d'un fil determinat?
Sí. Podeu bloquejar un objecte col·locant-lo en un bloc 'sincronitzat'. L'objecte bloquejat és inaccessible per a qualsevol fil que no sigui el que l'ha reclamat explícitament.
24) Què és la sincronització estàtica?
Si feu que qualsevol mètode estàtic estigui sincronitzat, el bloqueig estarà a la classe no a l'objecte. Si fem servir la paraula clau synchronized abans d'un mètode perquè bloquejarà l'objecte (un fil pot accedir a un objecte alhora) però si fem servir static synchronized així bloquejarà una classe (un fil pot accedir a una classe alhora). Més detalls.
25) Quina diferència hi ha entre notify() i notifyAll()?
El notify() s'utilitza per desbloquejar un fil en espera, mentre que el mètode notifyAll() s'utilitza per desbloquejar tots els fils en estat d'espera.
26) Què és el bloqueig?
El bloqueig és una situació en què cada fil està esperant un recurs que està subjecte a un altre fil en espera. En aquesta situació, cap dels fils s'executa ni té l'oportunitat de ser executat. En canvi, existeix un estat d'espera universal entre tots els fils. El bloqueig és una situació molt complicada que pot trencar el nostre codi en temps d'execució.
Més detalls.27) Com detectar una condició de bloqueig? Com es pot evitar?
Podem detectar la condició de bloqueig executant el codi a cmd i recopilant l'abocament de fils, i si hi ha algun bloqueig al codi, apareixerà un missatge a cmd.
Maneres d'evitar la condició de bloqueig a Java:
28) Què és Thread Scheduler a Java?
A Java, quan creem els fils, es supervisen amb l'ajuda d'un Thread Scheduler, que és la part de JVM. El planificador de fils només és responsable de decidir quin fil s'ha d'executar. El programador de fils utilitza dos mecanismes per programar els fils: Preemptive i Time Slicing.
El programador de fils de Java també funciona per decidir el següent per a un fil:- Selecciona la prioritat del fil.
- Determina el temps d'espera d'un fil
- Comprova la naturalesa del fil
29) Cada fil té la seva pila en programació multifil?
Sí, en la programació multifil cada fil manté la seva àrea de pila pròpia o separada a la memòria a causa de la qual cada fil és independent l'un de l'altre.
30) Com s'aconsegueix la seguretat d'un fil?
Si un mètode o un objecte de classe pot ser utilitzat per diversos fils alhora sense cap condició de carrera, aleshores la classe és segura. La seguretat de fil s'utilitza per fer que un programa sigui segur per utilitzar-lo en programació multifil. Es pot aconseguir de les maneres següents:
matriu en cadena
- Sincronització
- Utilitzant la paraula clau Volàtil
- Utilitzant un mecanisme basat en bloqueig
- Ús de classes d'embolcall atòmic
31) Què és la condició de carrera?
Una condició de cursa és un problema que es produeix en la programació multifil quan s'executen diversos fils accedint simultàniament a un recurs compartit al mateix temps. L'ús adequat de la sincronització pot evitar la condició de carrera.
32) Quina és la paraula clau volàtil a Java?
La paraula clau volàtil s'utilitza en la programació multifil per aconseguir la seguretat del fil, ja que un canvi en una variable volàtil és visible per a tots els altres fils, de manera que una variable pot ser utilitzada per un fil alhora.
33) Què entens per grup de fils?
- El grup de fils de Java representa un grup de fils de treball, que estan esperant que s'assigni la tasca.
- Els fils del grup de fils són supervisats pel proveïdor de serveis que extreu un fil del grup i li assigna una feina.
- Després de completar la tasca donada, el fil va tornar a arribar al grup de fils.
- La mida del grup de fils depèn del nombre total de fils reservats per a l'execució.
Els avantatges del grup de fils són:
- Amb un grup de fils, es pot millorar el rendiment.
- Si feu servir un grup de fils, es pot produir una millor estabilitat del sistema.
Preguntes d'entrevista de concurrència
34) Quins són els components principals de l'API de concurrència?
L'API de concurrència es pot desenvolupar mitjançant la classe i les interfícies del paquet java.util.Concurrent. Hi ha les classes i interfícies següents al paquet java.util.Concurrent.
- Executor
- FarkJoinPool
- Servei d'execució
- Servei d'execució programat
- Futur
- TimeUnit(Enum)
- CountdownLatch
- Barrera Cíclica
- Semàfor
- ThreadFactory
- BlockingQueue
- DelayQueue
- Panys
- Phaser
35) Què és la interfície de l'executor a l'API de concurrència a Java?
La interfície d'execució proporcionada pel paquet java.util.concurrent és la interfície senzilla que s'utilitza per executar la nova tasca. El mètode execute() de la interfície Executor s'utilitza per executar una ordre donada. La sintaxi del mètode execute() es mostra a continuació.
void execute (ordre executable)
Considereu l'exemple següent:
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(); } } } } Sortida
Running Thread! Thread Completed
36) Què és BlockingQueue?
El java.util.concurrent.BlockingQueue és la subinterfície de Queue que admet operacions com ara esperar la disponibilitat d'espai abans d'inserir un valor nou o esperar que la cua quedi no buida abans de recuperar-ne un element. Considereu l'exemple següent.
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(); } } } } Sortida
Added: 96 Removed: 96 Added: 8 Removed: 8 Added: 5 Removed: 5
37) Com implementar el problema productor-consumidor mitjançant BlockingQueue?
El problema productor-consumidor es pot resoldre utilitzant BlockingQueue de la següent manera.
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't guarantee it.</li> <li>Lock interface provides the option of timeout if the lock is not granted whereas the synchronized block doesn'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('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(); } } } } </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�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't be canceled.</p> <p> <strong>Syntax</strong> </p> <p>public class FutureTask extends Object implements RunnableFuture</p> <hr></10;> 38) Quina diferència hi ha entre la interfície Java Callable i la interfície Runnable?
La interfície Callable i Runnable són utilitzades per les classes que volien executar-se amb diversos fils. Tanmateix, hi ha dues diferències principals entre tots dos:
millorat per al bucle java
- Una interfície Callable pot retornar un resultat, mentre que la interfície Runnable no pot retornar cap resultat.
- Una interfície Callable pot llançar una excepció marcada, mentre que la interfície Runnable no pot llançar una excepció marcada.
- Una interfície Callable no es pot utilitzar abans de Java 5, mentre que la interfície Runnable es pot utilitzar.
39) Quina és l'acció atòmica en concurrència a Java?
- L'acció atòmica és l'operació que es pot realitzar en una sola unitat d'una tasca sense cap interferència de les altres operacions.
- L'acció atòmica no es pot aturar entre una tasca. Un cop iniciat, s'atura només després de completar la tasca.
- Una operació d'increment com ara a++ no permet una acció atòmica.
- Totes les operacions de lectura i escriptura de la variable primitiva (excepte long i double) són l'operació atòmica.
- Totes les operacions de lectura i escriptura de la variable volàtil (incloent-hi llarga i doble) són operacions atòmiques.
- Els mètodes Atomic estan disponibles al paquet java.util.Concurrent.
40) Què és la interfície de bloqueig a l'API de concurrència a Java?
La interfície java.util.concurrent.locks.Lock s'utilitza com a mecanisme de sincronització. Funciona de manera similar al bloc sincronitzat. Hi ha algunes diferències entre el bloqueig i el bloc sincronitzat que es donen a continuació.
- La interfície de bloqueig proporciona la garantia de la seqüència en què es donarà l'accés al fil d'espera, mentre que el bloc sincronitzat no ho garanteix.
- La interfície de bloqueig ofereix l'opció de temps d'espera si el bloqueig no s'atorga, mentre que el bloc sincronitzat no ho proporciona.
- Els mètodes de la interfície de bloqueig, és a dir, Lock() i Unlock() es poden cridar de diferents mètodes, mentre que un sol bloc sincronitzat s'ha d'incloure completament en un únic mètode.
41) Expliqueu la interfície ExecutorService.
La interfície ExecutorService és la subinterfície de la interfície Executor i afegeix les funcions per gestionar el cicle de vida. Considereu l'exemple següent.
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(); } } } } Sortida
Shutdown executor shutdown finished
42) Quina diferència hi ha entre la programació síncrona i la programació asíncrona pel que fa a un fil?
Programació síncrona: En el model de programació síncrona, s'assigna un fil per completar una tasca i, per tant, el fil comença a treballar-hi, i només està disponible per a altres tasques un cop finalitza la tasca assignada.
Programació asíncrona: A la programació asíncrona, un treball es pot completar amb diversos fils i, per tant, proporciona la màxima usabilitat dels diferents fils.
43) Què entens per Callable i Future a Java?
Interfície cridable de Java: A Java5, la interfície cridable va ser proporcionada pel paquet java.util.concurrent. És similar a la interfície Runnable, però pot retornar un resultat i pot llançar una excepció. També proporciona un mètode run() per a l'execució d'un fil. Java Callable pot retornar qualsevol objecte ja que utilitza el genèric.
Sintaxi:
interfície pública cridable
Interfície de Java Future: La interfície de Java Future dóna el resultat d'un procés concurrent. La interfície Callable retorna l'objecte de java.util.concurrent.Future.
Java Future ofereix els mètodes següents per a la implementació.
44. Quina diferència hi ha entre la interfície ScheduledExecutorService i ExecutorService?
ExecutorServcie i ScheduledExecutorService són les interfícies del paquet java.util.Concurrent, però scheduledExecutorService proporciona alguns mètodes addicionals per executar les tasques executables i cridables amb el retard o cada període de temps determinat.
45) Definiu la classe FutureTask a Java?
La classe Java FutureTask proporciona una implementació bàsica de la interfície Future. El resultat només es pot obtenir si s'ha completat l'execució d'una tasca, i si no s'aconsegueix el càlcul, es bloquejarà el mètode get. Si s'ha completat l'execució, no es pot reiniciar i no es pot cancel·lar.
Sintaxi
La classe pública FutureTask amplia Objecte implementa RunnableFuture