Многонишковостта и синхронизацията се считат за типична глава в програмирането на java. В компаниите за разработка на игри най-често се задават въпроси за интервюта, свързани с многопоточност. По-долу е даден списък с често задавани въпроси за интервю за многопоточност и паралелност на Java.

Многонишкови въпроси за интервю

1) Какво е многопоточност?

Многонишковостта е процес на изпълнение на множество нишки едновременно. Многонишковостта се използва за получаване на многозадачност. Консумира по-малко памет и осигурява бърза и ефективна работа. Основните му предимства са:

• Нишките споделят едно и също адресно пространство.
• Нишката е лека.
• Цената на комуникацията между процесите е ниска.

2) Каква е нишката?

Нишката е лек подпроцес. Това е отделен път на изпълнение, тъй като всяка нишка се изпълнява в различна стекова рамка. Един процес може да съдържа множество нишки. Нишките споделят ресурсите на процеса, но все пак се изпълняват независимо.

3) Правете разлика между процес и нишка?

Има следните разлики между процеса и нишката.

• Програмата в изпълнение се нарича процес, докато; Нишката е подмножество на процеса
• Процесите са независими, докато нишките са подмножеството на процеса.
• Процесът има различно адресно пространство в паметта, докато нишките съдържат споделено адресно пространство.
• Превключването на контекст е по-бързо между нишките в сравнение с процесите.
• Комуникацията между процесите е по-бавна и скъпа от комуникацията между нишки.
• Всяка промяна в родителския процес не засяга дъщерния процес, докато промените в родителската нишка могат да повлияят на дъщерната нишка.

4) Какво разбирате под комуникация между нишки?

• Процесът на комуникация между синхронизирани нишки се нарича комуникация между нишки.
• Комуникацията между нишки се използва, за да се избегне анкетирането на нишки в Java.
• Нишката е поставена на пауза в своята критична секция и на друга нишка е разрешено да влезе (или да се заключи) в същата критична секция, за да бъде изпълнена.
• Може да се получи чрез методите wait(), notify() и notifyAll().

5) Каква е целта на метода wait() в Java?

Методът wait() се предоставя от класа Object в Java. Този метод се използва за комуникация между нишки в Java. Java.lang.Object.wait() се използва за пауза на текущата нишка и изчакване, докато друга нишка не извика метода notify() или notifyAll(). Синтаксисът му е даден по-долу.

публично окончателно празно изчакване ()

6) Защо методът wait() трябва да се извиква от синхронизирания блок?

Трябва да извикаме метода за изчакване, в противен случай той ще изхвърли java.lang.IllegalMonitorStateException изключение. Освен това се нуждаем от метода wait() за комуникация между нишки с notify() и notifyAll(). Следователно той трябва да присъства в синхронизирания блок за правилна и правилна комуникация.

7) Какви са предимствата на многопоточността?

Многопоточното програмиране има следните предимства:

• Многонишковостта позволява на приложението/програмата винаги да реагира на въвеждане, дори вече да работи с някои фонови задачи
• Многопоточността позволява по-бързото изпълнение на задачите, тъй като нишките се изпълняват независимо.
• Многонишковостта осигурява по-добро използване на кеш паметта, тъй като нишките споделят общите ресурси на паметта.
• Многонишковостта намалява броя на необходимия сървър, тъй като един сървър може да изпълнява множество нишки наведнъж.

8) Какви са състоянията в жизнения цикъл на една нишка?

Една нишка може да има едно от следните състояния по време на живота си:

ново:В това състояние обект на клас Thread се създава с помощта на нов оператор, но нишката не е активна. Нишката не стартира, докато не извикаме метода start().Работим:В това състояние нишката е готова за изпълнение след извикване на метода start(). Нишката обаче все още не е избрана от планировчика на нишки.Работи:В това състояние планировчикът на нишки избира нишката от състояние на готовност и нишката се изпълнява.Чакащ/блокиран:В това състояние една нишка не работи, но все още е жива, или чака другата нишка да приключи.Мъртъв/Прекратен:Нишката е в прекратено или мъртво състояние, когато методът run() излезе.

9) Каква е разликата между превантивното планиране и разделянето на времето?

При превантивно планиране задачата с най-висок приоритет се изпълнява, докато не навлезе в състояние на изчакване или мъртво състояние или не се появи задача с по-висок приоритет. При разделянето на времето дадена задача се изпълнява за предварително определен отрязък от време и след това влиза отново в набора от готови задачи. След това планировчикът определя коя задача трябва да се изпълни следващата въз основа на приоритета и други фактори.

10) Какво е превключване на контекста?

При превключването на контекст състоянието на процеса (или нишката) се съхранява, така че да може да бъде възстановено и изпълнението да може да бъде възобновено от същата точка по-късно. Превключването на контекст позволява на множество процеси да споделят един и същ процесор.

11) Разграничете класа Thread и интерфейса Runnable за създаване на Thread?

Нишката може да бъде създадена по два начина.

• Чрез разширяване на класа Thread
• Чрез внедряване на интерфейса Runnable

Основните разлики между двата начина обаче са дадени по-долу:

• Чрез разширяване на класа Thread не можем да разширим нито един друг клас, тъй като Java не позволява множество наследявания, докато имплементира интерфейса Runnable; можем също да разширим друг базов клас (ако е необходимо).
• Чрез разширяване на класа Thread, всяка от нишките създава уникален обект и се асоциира с него, докато имплементира интерфейса Runnable; множество нишки споделят един и същ обект
• Класът Thread предоставя различни вградени методи като getPriority(), isAlive и много други, докато интерфейсът Runnable предоставя един метод, т.е. run().

12) Какво означава методът join()?

Методът join() чака нишката да умре. С други думи, той кара текущо изпълняваните нишки да спрат изпълнението, докато нишката, към която се присъединява, не изпълни задачата си. Методът на присъединяване е претоварен в клас Thread по следните начини.

• public void join() хвърля InterruptedException
• public void join (дълги милисекунди) хвърля InterruptedException

13) Опишете предназначението и работата на метода sleep().

Методът sleep() в Java се използва за блокиране на нишка за определено време, което означава, че поставя на пауза изпълнението на нишка за определено време. Има два метода за това.

Синтаксис:

проста програма на python

• public static void sleep (дълги милисекунди) хвърля InterruptedException
• public static void sleep (дълги милисекунди, int nanos) хвърля InterruptedException

Работа на метода sleep().

Когато извикаме метода sleep(), той спира изпълнението на текущата нишка за даденото време и дава приоритет на друга нишка (ако е налична). Освен това, когато времето за изчакване приключи, предишната нишка отново променя състоянието си от чакащо на изпълняващо се и идва в работещо състояние и целият процес работи така, докато изпълнението не завърши.

14) Каква е разликата между метода wait() и sleep()?

15) Възможно ли е да стартирате нишка два пъти?

Не, не можем да рестартираме нишката, тъй като след като нишката бъде стартирана и изпълнена, тя преминава в състояние Dead. Следователно, ако се опитаме да стартираме нишка два пъти, тя ще даде runtimeException 'java.lang.IllegalThreadStateException'. Помислете за следния пример.

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

Изход

 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) Можем ли да извикаме метода run() вместо start()?

Да, извикването на метода run() директно е валидно, но няма да работи като нишка, вместо това ще работи като нормален обект. Няма да има превключване на контекста между нишките. Когато извикаме метода start(), той вътрешно извиква метода run(), който създава нов стек за нишка, докато директното извикване на run() няма да създаде нов стек.

17) Какво ще кажете за нишките на демоните?

Демон нишките са нишки с нисък приоритет, които осигуряват фонова поддръжка и услуги на потребителските нишки. Демон нишката се прекратява автоматично от JVM, ако програмата остане само с демон нишката и всички останали потребителски нишки са прекратени/умрели. В класа Thread има два метода за нишка на демон:

public void setDaemon(булев статус):Използва се за маркиране на демон нишка на нишка или потребителска нишка.публичен булев isDaemon():Той проверява нишката е демон или не.

18) Можем ли да направим потребителската нишка като демон нишка, ако нишката е стартирана?

Не, ако го направите, това ще хвърли IllegalThreadStateException. Следователно можем да създадем демон нишка само преди стартиране на нишката.

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

Изход

 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) Какво е кука за изключване?

Куката за изключване е нишка, която се извиква имплицитно преди JVM да се изключи. Така че можем да го използваме, за да извършим почистване на ресурса или да запазим състоянието, когато JVM се изключи нормално или внезапно. Можем да добавим кука за изключване, като използваме следния метод:

html поле със списък

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

Някои важни точки относно куките за изключване са:

• Кукичките за изключване са инициализирани, но могат да бъдат стартирани само когато се е случило изключване на JVM.
• Куките за изключване са по-надеждни от finalizer(), защото има много по-малко шансове куките за изключване да не се изпълняват.
• Куката за изключване може да бъде спряна чрез извикване на метода halt(int) на класа Runtime.

20) Кога трябва да прекъснем нишка?

Трябва да прекъснем нишка, когато искаме да излезем от състоянието на заспиване или изчакване на нишка. Можем да прекъснем нишка, като извикаме interrupt()�изхвърляйки InterruptedException.

21) Каква е синхронизацията?

Синхронизацията е способността да се контролира достъпът на множество нишки до всеки споделен ресурс. Използвано е:

1. За предотвратяване на смущения в резбата.
2. За предотвратяване на проблем с последователността.

Когато множество нишки се опитат да изпълнят една и съща задача, има възможност за грешен резултат, следователно, за да премахне този проблем, Java използва процеса на синхронизация, който позволява само една нишка да бъде изпълнена в даден момент. Синхронизирането може да се постигне по три начина:

• по синхронизирания метод
• чрез синхронизиран блок
• чрез статична синхронизация

Синтаксис за синхронизиран блок

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

22) Каква е целта на синхронизирания блок?

Блокът Synchronized може да се използва за извършване на синхронизация на всеки специфичен ресурс на метода. Само една нишка в даден момент може да се изпълнява на определен ресурс, а всички други нишки, които се опитват да влязат в синхронизирания блок, се блокират.

• Синхронизираният блок се използва за заключване на обект за всеки споделен ресурс.
• Обхватът на синхронизирания блок е ограничен до блока, върху който се прилага. Неговият обхват е по-малък от метод.

23)Може ли Java обектът да бъде заключен за изключителна употреба от дадена нишка?

да Можете да заключите обект, като го поставите в „синхронизиран“ блок. Заключеният обект е недостъпен за нито една нишка, различна от тази, която изрично го е заявила.

24) Какво е статична синхронизация?

Ако направите някой статичен метод като синхронизиран, заключването ще бъде върху класа, а не върху обекта. Ако използваме ключовата дума synchronized преди метод, тя ще заключи обекта (една нишка може да има достъп до обект наведнъж), но ако използваме static synchronized, тя ще заключи клас (една нишка може да има достъп до клас наведнъж). Повече информация.

25) Каква е разликата между notify() и notifyAll()?

Notify() се използва за деблокиране на една чакаща нишка, докато методът notifyAll() се използва за деблокиране на всички нишки в състояние на чакане.

26)Какво е задънената улица?

Безизходица е ситуация, при която всяка нишка чака ресурс, който се държи от друга чакаща нишка. В тази ситуация нито една от нишките не се изпълнява, нито получава шанс да бъде изпълнена. Вместо това съществува универсално състояние на изчакване сред всички нишки. Безизходицата е много сложна ситуация, която може да наруши нашия код по време на изпълнение.

27) Как да открием състояние на блокиране? Как може да се избегне?

Можем да открием състоянието на блокиране, като изпълним кода на cmd и съберем Dump на нишката и ако в кода има блокиране, тогава на cmd ще се появи съобщение.

кайли дженър братя и сестри

Начини за избягване на състоянието на блокиране в Java:

Избягвайте вложено заключване:Вложеното заключване е често срещаната причина за блокиране, тъй като блокиране възниква, когато предоставяме заключвания на различни нишки, така че трябва да дадем едно заключване само на една нишка в определен момент.Избягвайте ненужните ключалки:трябва да избягваме ключалките, които не са необходими.Използване на присъединяване към нишка:Присъединяването към нишка помага да изчакате нишка, докато друга нишка не завърши изпълнението си, така че можем да избегнем блокиране чрез максимално използване на метода за присъединяване.

28) Какво е Thread Scheduler в java?

В Java, когато създаваме нишките, те се контролират с помощта на Thread Scheduler, който е част от JVM. Планировчикът на нишки е отговорен само за решаването коя нишка трябва да бъде изпълнена. Планировчикът на нишки използва два механизма за планиране на нишките: изпреварващ и отрязване на времето.

• Той избира приоритета на нишката.
• Той определя времето за изчакване на нишка
• Той проверява природата на нишката

29) Всяка нишка има ли свой стек в многопоточното програмиране?

Да, при многопоточното програмиране всяка нишка поддържа своя собствена или отделна стекова област в паметта, поради което всяка нишка е независима една от друга.

30) Как се постига безопасността на една нишка?

Ако даден метод или обект на клас може да се използва от множество нишки наведнъж без условие за състезание, тогава класът е безопасен за нишки. Безопасността на нишките се използва, за да направи една програма безопасна за използване при многонишково програмиране. Може да се постигне по следните начини:

• Синхронизация
• Използване на ключова дума Volatile
• Използване на механизъм, базиран на заключване
• Използване на класове атомарна обвивка

31) Какво е състезателно състояние?

Условието за състезание е проблем, който възниква при многопоточното програмиране, когато различни нишки се изпълняват едновременно, осъществявайки достъп до споделен ресурс по едно и също време. Правилното използване на синхронизация може да избегне състоянието Race.

32) Коя е променливата ключова дума в java?

Ключовата дума volatile се използва в многопоточното програмиране за постигане на безопасността на нишката, тъй като промяната в една променлива променлива е видима за всички останали нишки, така че една променлива може да се използва от една нишка наведнъж.

33) Какво разбирате под набор от нишки?

• Java Thread pool представлява група от работни нишки, които чакат задачата да бъде разпределена.
• Нишките в пула от нишки се контролират от доставчика на услуги, който изтегля една нишка от пула и й присвоява работа.
• След завършване на дадената задача нишката отново дойде в пула на нишките.
• Размерът на пула от нишки зависи от общия брой нишки, съхранявани в резерв за изпълнение.

Предимствата на пула от нишки са:

• С помощта на пул от нишки производителността може да бъде подобрена.
• С помощта на пул от нишки може да се получи по-добра стабилност на системата.

Въпроси за интервю за паралелност

34) Кои са основните компоненти на API за едновременност?

API за едновременност може да се разработи с помощта на класа и интерфейсите на пакета java.util.Concurrent. В пакета java.util.Concurrent има следните класове и интерфейси.

• Изпълнител
• FarkJoinPool
• ExecutorService
• ScheduledExecutorService
• Бъдеще
• TimeUnit(Enum)
• CountDownLatch
• Циклична бариера
• Семафор
• ThreadFactory
• Блокираща опашка
• DelayQueue
• Брави
• Фейзер

35) Какво представлява интерфейсът на Executor в API за паралелност в Java?

Интерфейсът на изпълнителя, предоставен от пакета java.util.concurrent, е простият интерфейс, използван за изпълнение на новата задача. Методът execute() на интерфейса Executor се използва за изпълнение на дадена команда. Синтаксисът на метода execute() е даден по-долу.

void изпълнение (Команда за изпълнение)

Разгледайте следния пример:

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

Изход

 Running Thread! Thread Completed 

36) Какво е BlockingQueue?

Java.util.concurrent.BlockingQueue е подинтерфейсът на Queue, който поддържа операции като изчакване за наличността на пространството преди вмъкване на нова стойност или изчакване опашката да стане непразна, преди да извлече елемент от нея. Помислете за следния пример.

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

Изход

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

37) Как да внедрим проблема производител-потребител с помощта на BlockingQueue?

Проблемът производител-потребител може да бъде решен чрез използване на BlockingQueue по следния начин.

 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) Каква е разликата между Java Callable интерфейс и Runnable интерфейс?

И интерфейсът Callable и Runnable се използват от класовете, които искат да се изпълнят с множество нишки. Има обаче две основни разлики между двете:

• Callable интерфейсът може да върне резултат, докато Runnable интерфейсът не може да върне никакъв резултат.
• Интерфейсът Callable може да хвърли проверено изключение, докато интерфейсът Runnable не може да хвърли проверено изключение.
• Callable интерфейс не може да се използва преди Java 5, докато Runnable интерфейс може да се използва.

39) Какво е атомарното действие в паралелността в Java?

• Атомното действие е операцията, която може да се извърши в отделна единица от задача без намеса на другите операции.
• Действието Atomic не може да бъде спряно между задачите. Веднъж стартирано, запълването спира само след завършване на задачата.
• Операция за увеличаване като a++ не позволява атомарно действие.
• Всички операции за четене и запис за примитивната променлива (с изключение на long и double) са атомарни операции.
• Всички операции за четене и запис за променливата променлива (включително long и double) са атомарни операции.
• Методите Atomic са налични в пакета java.util.Concurrent.

40) Какво представлява интерфейсът за заключване в API за паралелност в Java?

Интерфейсът java.util.concurrent.locks.Lock се използва като механизъм за синхронизиране. Работи подобно на синхронизирания блок. Има няколко разлики между заключващия и синхронизирания блок, които са дадени по-долу.

• Интерфейсът за заключване осигурява гаранция за последователност, в която чакащата нишка ще получи достъп, докато синхронизираният блок не го гарантира.
• Интерфейсът за заключване предоставя опция за изчакване, ако заключването не е предоставено, докато синхронизираният блок не предоставя това.
• Методите на интерфейса Lock, т.е. Lock() и Unlock() могат да бъдат извикани в различни методи, докато единичен синхронизиран блок трябва да се съдържа изцяло в един метод.

41) Обяснете интерфейса на ExecutorService.

ExecutorService Interface е подинтерфейс на Executor интерфейс и добавя функции за управление на жизнения цикъл. Помислете за следния пример.

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

Изход

 Shutdown executor shutdown finished 

42) Каква е разликата между синхронното програмиране и асинхронното програмиране по отношение на нишка?

Синхронно програмиране: В модела на синхронно програмиране нишката е назначена за изпълнение на задача и следователно нишката е започнала да работи по нея и е достъпна само за други задачи, след като приключи възложената задача.

Асинхронно програмиране: При асинхронното програмиране една работа може да бъде изпълнена от множество нишки и следователно осигурява максимална използваемост на различните нишки.

43) Какво разбирате под Callable и Future в Java?

Java Callable интерфейс: В Java5 интерфейсът за извикване беше предоставен от пакета java.util.concurrent. Той е подобен на интерфейса Runnable, но може да върне резултат и може да хвърли изключение. Той също така предоставя метод run() за изпълнение на нишка. Java Callable може да върне всеки обект, тъй като използва Generic.

Синтаксис:

публичен интерфейс Callable

Java Future интерфейс: Интерфейсът на Java Future дава резултат от паралелен процес. Интерфейсът Callable връща обекта на java.util.concurrent.Future.

Java Future предоставя следните методи за реализация.

cancel(boolean�mayInterruptIfRunning):Използва се за отмяна на изпълнението на възложената задача.получи():Той изчаква времето, ако изпълнението не е завършено и след това извлича резултата.isCancelled():Връща булевата стойност, тъй като връща true, ако задачата е била отменена преди завършването.готово е():Връща true, ако заданието е завършено успешно, иначе връща false.

44. Каква е разликата между интерфейса ScheduledExecutorService и ExecutorService?

ExecutorServcie и ScheduledExecutorService са интерфейсите на пакета java.util.Concurrent, но scheduledExecutorService предоставя някои допълнителни методи за изпълнение на Runnable и Callable задачи със закъснение или всеки фиксиран период от време.

45) Дефиниране на клас FutureTask в Java?

Класът Java FutureTask предоставя базова реализация на интерфейса Future. Резултатът може да бъде получен само ако изпълнението на една задача е завършено и ако изчислението не бъде постигнато, методът get ще бъде блокиран. Ако изпълнението е завършено, то не може да бъде рестартирано и не може да бъде отменено.

vba

Синтаксис

публичен клас FutureTask разширява Object прилага RunnableFuture