Мени

Паралелност у Јави: Оквир за семафор и извршитеље

concurrency java semaphore

Испробајте Наш Инструмент За Елиминисање Проблема

У овом водичу ће бити речи о компонентама пакета јава.утил.цонцуррент као што су Јава Семапхоре, Екецутор Фрамеворк, ЕкецуторСервице за примену Цонцурренци-а у Јави:

Из наших претходних Јава туторијала знамо да Јава платформа подржава истовремено програмирање од темеља. Основна јединица истодобности је нит, а ми смо детаљно разговарали о нитима и мултитхреадингу у Јави.

Од Јаве 5 надаље, пакет под називом „јава.утил.цонцуррент“ додан је на Јава платформу. Овај пакет садржи скуп класа и библиотека који програмеру олакшавају развој истовремених (вишенитних) апликација. Користећи овај пакет, не морамо писати сложене класе јер имамо спремне имплементације већине истовремених концепата.

=> Овде проверите СВЕ Јава туторијале.

јава.утил.цонцуррент пакет

У овом упутству ћемо размотрити различите компоненте пакета јава.утил.цонцуррент које се тичу паралелности и мултитхреадинга у Јави.

Шта ћете научити:

јава.утил.цонцуррент пакет

У наставку су наведене разне компоненте пакета јава.утил.цонцуррент које се тичу истовремености и мултитреадинга у Јави. Истражимо детаљно сваку компоненту уз помоћ једноставних примера програмирања. Неке компоненте ћемо
дискутују о:

  • Оквир извршиоца
  • ЕкецуторСервице
  • ТхреадПоол
  • Цаллабле
  • Браве- РеентрантЛоцк
  • Семафор
  • ФоркЈоинПоол

Извршни оквир у Јави

Извршни оквир у Јави објављен је издањем ЈДК 5. Извршни оквир (јава.утил.цонцуррент.Екецутор) је оквир који се састоји од компонената које нам помажу да ефикасно рукујемо са више нити.

Коришћењем извршног оквира можемо покретати објекте који се могу покренути поновном употребом већ постојећих нити. Не треба да стварамо нове нити сваки пут када треба да покренемо објекте.

Извршни АПИ раздваја или раздваја извршење задатка од стварног задатка помоћу Извршилац . Извршитељ је усредсређен на извршни интерфејс и има под-интерфејсе тј. ЕкецуторСервице и разред ТхреадПоолЕкецутор.

Тако помоћу Екецутор-а морамо само створити Руннабле објекте и послати их извршитељу који их извршава.

Неке од најбољих пракси којих се треба придржавати током употребе оквира Екецутор су,

  1. Требали бисмо унакрсно провјерити и планирати код за преглед најбољих листа како бисмо могли открити мртву тачку као и заостатак у коду.
  2. Јава код увек треба извршавати помоћу алата за статичку анализу. Примери алати за статичку анализу су ФиндБугс и ПМД.
  3. Не бисмо требали ухватити само изузетке, већ и грешке у програмима са више нити.

Хајде сада да разговарамо о компонентама програма Екецутор Фрамеворк у Јави.

Извршилац

Извршитељ се може дефинисати као интерфејс који се користи за представљање објекта који извршава задатке који су му дати. Да ли ће се задатак покренути на тренутној или новој нити зависи од тачке одакле је иницирање покренуто, што даље зависи од имплементације.

Дакле, помоћу програма Екецутор можемо раздвојити задатке од стварног задатка, а затим их асинхроно покренути.

Међутим, извршавање задатка помоћу извршиоца не мора бити асинхроно. Извршитељи такође могу одмах да позову задатак користећи нит за позивање.

Доље је дат пример кода за креирање егзекуторске инстанце:

public class Invoker implements Executor { @Override public void execute (Runnable r_interface) { r_interface.run(); } }

Једном када се покретач креира, као што је приказано горе, можемо га користити за извршавање задатка на следећи начин.

public void execute () { Executor executor = new Invoker (); executor.execute ( () -> { //perform task }); }

Имајте на уму да ако извршитељ не прихвати задатак, он баца РејецтедЕкецутионЕкцептион.

ЕкецуторСервице

ЕкецуторСервице (јава.утил.цонцуррент.ЕкецуторСервице) распоређује предате задатке према доступности нити, а такође одржава меморијски ред. ЕкецуторСервице делује као комплетно решење за асинхрону обраду задатака.

Да бисмо користили ЕкецуторСервице у коду, креирамо класу Руннабле. ЕкецуторСервице одржава спремиште нити и такође додељује задатке нитима. Задаци се такође могу поставити у ред у случају да нит није доступна.

Доље дат је једноставан пример ЕкецуторСервице.

import java.util.concurrent.*; public class Main { public static void main(String() args) { //create ExecutorService instance with 10 threads ExecutorService executor_Service = Executors.newFixedThreadPool(10); //assign the service to Runnable instance executor_Service.execute(new Runnable() { @Override public void run() { //print the message System.out.println('Simple Example of ExecutorService!!!'); } }); //shutdown executorService executor_Service.shutdown(); } }

Оутпут

излаз - ЕкецуторСервице

У горе наведеном програму креирамо једноставну инстанцу ЕкецуторСервице са базеном нити који се састоји од 10 нити. Затим се додељује инстанци Руннабле и извршава за испис горње поруке. Након штампања поруке, ЕкецуторСервице се искључује.

Тхреад Поол

Пупање нити у Јави је група радничких нити које се могу поново користити више пута и додијелити им послове.

Складиште нити садржи групу нити фиксне величине. Свака нит се извлачи из спремишта нити и добављач услуга јој додељује задатак. Када се додељени посао доврши, нит се поново даје спремишту нити.

Спремиште нити је корисно јер не морамо стварати нову нит сваки пут када је задатак доступан, чиме се побољшавају перформансе. Користи се у апликацијама у стварном времену које користе Сервлет и ЈСП где се спремишта нити користе за обраду захтева.

У вишенитним апликацијама, Тхреад Поол штеди ресурсе и помаже у задржавању паралелизма у унапред дефинисаним границама.

Доле наведени Јава програм приказује Тхреад поол у ​​Јави.

import java.util.concurrent.ExecutorService; import java.util.concurrent.Executors; class WorkerThreadClass implements Runnable { private String message; //thread class constructor public WorkerThreadClass(String s){ this.message=s; } //run method for thread public void run() { System.out.println(' Start: '+message); processmessage(); //sleep between start and end System.out.println(' End: '+ message); } //processmessage method => sleeps the thread for 2 sec private void processmessage() { try { Thread.sleep(2000); } catch (InterruptedException e) { e.printStackTrace(); } } } public class Main { public static void main(String() args) { //create a ExecutorService instance ExecutorService executor = Executors.newFixedThreadPool(5);//creating a pool of 5 threads //create thread instances and execute them for (int i = 0; i <5; i++) { Runnable workerThrd = new WorkerThreadClass('Thread_' + i); executor.execute(workerThrd);//calling execute method of ExecutorService } //shutdown ExecutorService executor.shutdown(); while (!executor.isTerminated()) { } System.out.println('Finished all threads'); } }

Оутпут

излаз - Тхреад Поол

У горе наведеним програмима постоји спрема нити од 5 нити које су креиране методом „невФикедТхреадПоол“. Тада се нити креирају и додају у спремиште и додељују извршној служби за извршење.

Називно у Јави

Већ знамо да можемо створити нити користећи два приступа. Један приступ је проширивање класе Тхреад, док је други приступ имплементацијом Руннабле интерфејса.

Међутим, нитима створеним помоћу Руннабле интерфејса недостаје једна карактеристика, тј. Не враћа резултат када је нит завршена или рун () довршава извршење. Овде се појављује интерфејс који се може позвати.

Помоћу интерфејса Цаллабле дефинишемо задатак тако да даје резултат. То такође може донети изузетак. Интерфејс Цаллабле је део јава.утил.цонцуррент пакета.

Интерфејс Цаллабле пружа цалл () методу која се налази на сличним линијама као и рун () методу коју пружа Руннабле интерфејс са једином разликом што метода цалл () враћа вредност и баца означени изузетак.

Метода цалл () Цаллабле интерфејса има следећи прототип.

public Object call () throws Exception;

Пошто метода цалл () враћа Објецт, главна нит мора бити свесна тога.

Стога би повратна вредност требало да буде ускладиштена у другом објекту који је познат главној нити. Овој сврси служи објекат „Будућност“. Будући објекат је објекат који садржи резултат који враћа нит. Или другим речима, задржаће резултат када се Цаллабле врати.

Цаллабле енкапсулира задатак који би требало да се изводи на другој нити. Објекат Футуре чува резултат враћен из друге нити.

Интерфејс који се може позвати не може се користити за креирање нити. Треба нам Руннабле да створимо нит. Тада је за чување резултата потребан објекат Футуре. Јава нуди конкретан тип назван „ФутуреТаск“ који комбинује функционалност имплементирајући и Руннабле и Футуре.

Ми креирамо ФутуреТаск пружајући конструктору Цаллабле. Овај ФутуреТаск објекат се затим даје конструктору класе Тхреад да креира Тхреад објекат.

Доље је дат Јава програм који демонстрира интерфејс који се може позвати и објекат Будућност. У овом програму користимо и објекат ФутуреТаск.

Као што је већ поменуто, у програму креирамо класу која имплементира Цаллабле интерфејс са замењеном цалл () методом. У главној методи креирамо 10 објеката ФутуреТаск. Сваки конструктор објекта има објект класе Цаллабле као свој аргумент. Тада је објекат ФутуреТаск повезан са инстанцом нити.

Отуда индиректно креирамо нит користећи објект интерфејса Цаллабле.

import java.util.Random; import java.util.concurrent.Callable; import java.util.concurrent.FutureTask; //create a class implementing Callable interface class CallableDemo implements Callable { //define call () method public Object call() throws Exception { Random generator = new Random(); Integer randomNumber = generator.nextInt(10); Thread.sleep(randomNumber * 1000); return randomNumber; } } public class Main { public static void main(String() args) throws Exception { // Array of FutureTask objects FutureTask() randomNumberTasks = new FutureTask(10); for (int i = 0; i <10; i++) { Callable callable = new CallableDemo(); // Create the FutureTask with Callable class randomNumberTasks(i) = new FutureTask(callable); // create thread with FutureTask Thread t = new Thread(randomNumberTasks(i)); //start the thread t.start(); } System.out.println('The contents of FutureTask objects:'); for (int i = 0; i < 10; i++) { // get() contents of FutureTask System.out.print(randomNumberTasks(i).get() + ' '); } } }

Оутпут

излаз - Позива се у Јави

Као што је приказано у горњем програму, цалл () метода Цаллабле која је замењена у класи која примењује Цаллабле генерише случајне бројеве. Једном када је нит покренута, она приказује ове случајне бројеве.

Такође, у главној функцији користимо објекте ФутуреТаск. Како имплементира интерфејс за будућност, не треба да складиштимо резултате у објектима Тхреад. Слично томе, можемо отказати задатак, проверити да ли је покренут или довршен, а такође добити резултат помоћу објекта ФутуреТаск.

РеентрантЛоцк у Јави

У последњем водичу детаљно смо разговарали о синхронизацији нити користећи синхронизовану кључну реч. Употреба синхронизоване речи за синхронизацију нити је основна метода и донекле је крута.

Користећи синхронизовану кључну реч, нит се може закључати само једном. Такође, након што једна нит изађе из синхронизованог блока, следећа нит узима закључавање. Не постоји ред чекања. Ови проблеми могу проузроковати изгладњивање неке друге нити, јер можда неће дуго моћи приступити ресурсима.

Да бисмо се позабавили овим проблемима, потребан нам је флексибилан метод синхронизације нити. „Реентрант Лоцкс“ је овај метод на Јави који омогућава синхронизацију са далеко већом флексибилношћу.

Класа „РеентрантЛоцк“ примењује Реентрант браве и део је пакета „импорт јава.утил.цонцуррент.лоцкс“. Класа РеентрантЛоцк обезбеђује синхронизацију метода за приступ дељеним ресурсима. Класе такође имају методе закључавања и откључавања за закључавање / откључавање ресурса када им се приступа нитима.

Једна необична карактеристика РеентрантЛоцк-а је што нит може више пута закључати дељени ресурс користећи РеентрантЛоцк. Пружа број задржавања који је постављен на један када нит закључа ресурс.

Нит може поново да уђе и приступи ресурсу пре откључавања. Сваки пут када нит приступа ресурсу помоћу закључавања Реентрант, број задржавања повећава се за један. За свако откључавање, број задржавања смањује се за један.

Када број задржавања достигне 0, дељени ресурс се откључава.

Класа РеентрантЛоцк такође пружа параметар правичности који је логичка вредност која се може проследити са конструктором браве. Када је параметар правичности постављен на труе, онда кад год једна нит отпусти браву, брава се преноси на нит са најдужим чекањем. Ово спречава гладовање.

Браве Реентрант могу се користити на следећи начин:

return_type method_name() { reentrantlock.lock(); try { //Do some work } catch(Exception e) { e.printStackTrace(); } finally { reentrantlock.unlock(); } }

Имајте на уму да је изјава за откључавање за РеентрантЛоцк увек у коначно блоку. Ово гарантује ослобађање браве чак и ако се изузме изузетак.

Применимо Јава програм да бисмо разумели РеентрантЛоцк.

import java.text.SimpleDateFormat; import java.util.Date; import java.util.concurrent.*; import java.util.concurrent.locks.ReentrantLock; //thread class that implements Runnable interface class ThreadClass implements Runnable { String task_name; //define ReentrantLock object ReentrantLock thrd_lck; //ThreadClass constructor initialized lock and task name public ThreadClass(ReentrantLock r_lock, String t_name) { thrd_lck = r_lock; task_name = t_name; } //thread run () method public void run() { boolean bool_val = false; while (!bool_val) { //check for Outer Lock boolean tryLock_val = thrd_lck.tryLock(); // if lock is free, do the following if(tryLock_val) { try { for(int i=0;i<=6;i++) { if(i>=2) { thrd_lck.lock(); Thread thread_one = new Thread(); System.out.println('Thread Created.....'); if(i==3) { thread_one.setName('Maint Thread2'); System.out.println('Thread Created.....'); } } if(i==4) thrd_lck.unlock(); break; } System.out.println('ReentrantLock=>Is locked after sleep(1500) : ' + thrd_lck.isLocked()); System.out.println('Work done for task : ' + task_name ); bool_val = true; } catch(Exception e) { e.printStackTrace(); } } } } } public class Main { public static void main(String() args) { //define ReentrantLock lock object and service pool ReentrantLock reentrant_lock = new ReentrantLock(); ExecutorService pool = Executors.newFixedThreadPool(2); //create thread instance and pass lock and task name Runnable worker_thread = new ThreadClass(reentrant_lock, 'ThreadJob'); //execute the thread in exec pool pool.execute(worker_thread); //shut down the pool pool.shutdown(); } }

Оутпут

излаз - РеентрантЛоцк

У горенаведеном програму створили смо нит и за њу користили РеентрантЛоцк. Коришћењем РеентрантЛоцк-а може се приступити дељеном ресурсу.

Семафор у Јави

Следећи метод синхронизације нити је коришћење Семапхоре-а. Коришћењем ове конструкције која се назива семафор, приступ дељеном ресурсу контролише се преко бројача. Сигнали се шаљу између нити тако да можемо заштитити критични део и такође избећи пропуштене сигнале.

Семафор се може дефинисати као променљива која се користи за управљање истовременим процесима синхронизацијом тих процеса. Семафори се такође користе за синхронизацију приступа дељеном ресурсу и на тај начин избегавање тркачких услова. Дозвола коју нит даје за приступ дељеном ресурсу од стране семафора такође се назива дозвола.

У зависности од тога које функције обављају, семафори се могу поделити у две врсте:

# 1) Бинарни семафор: Бинарни семафор се користи за синхронизацију истовремених процеса и спровођење међусобног изузимања. Бинарни семафор претпоставља само две вредности, тј. 0 и 1.

# 2) Бројање семафора: Семафор за бројање има вредност која означава број процеса који могу ући у критични одељак. У било ком тренутку, вредност показује максималан број процеса који улазе у критични одељак.

Па како функционише Семафор?

Рад Семафора може се резимирати у следећим корацима:

  1. Ако је број семафора> 0, то значи да нит има дозволу за приступ критичном одељку, а затим се бројање смањује.
  2. У супротном, нит се блокира док се не стекне дозвола.
  3. Када се нит заврши са приступом дељеном ресурсу, дозвола се ослобађа и повећава се број семафора тако да друга нит може поновити горње кораке и стећи дозволу.

Горњи кораци рада семафора могу се сажети у доњој дијаграму тока.

Дијаграм тока семафора

У Јави не треба да примењујемо наш семафор, али он пружа а Семафор класа која имплементира функционалност семафора. Класа Семафор је део јава.утил.цонцуррент пакет.

Класа Семапхоре пружа следеће конструкторе помоћу којих можемо створити објект семафора:

Semaphore (int num_value) Semaphore (int num_value, boolean how)

Ево,

нум_валуе => почетна вредност броја дозвола која одређује број нити које могу приступити дељеном ресурсу.

како => поставља редослед којим ће нитима бити додељене дозволе (како = тачно). Ако је = фалсе, онда се такав редослед не поштује.

Сада ћемо применити Јава програм који ће демонстрирати Семафор који се користи за управљање заједничким приступом ресурсима и спречавање тркачких услова.

import java.util.concurrent.*; //class for shared resource class SharedRes { static int count = 0; } class ThreadClass extends Thread { Semaphore sem; String threadName; public ThreadClass(Semaphore sem, String threadName) { super(threadName); this.sem = sem; this.threadName = threadName; } @Override public void run() { // Thread T1 processing if(this.getName().equals('T1')) { System.out.println('Start: ' + threadName); try { System.out.println(threadName + ' :waiting for a permit.'); // acquire the permit sem.acquire(); System.out.println(threadName + ':Acquired permit'); // access shared resource for(int i=0; i <5; i++) { SharedRes.count++; System.out.println(threadName + ': ' + SharedRes.count); Thread.sleep(10); } } catch (InterruptedException exc) { System.out.println(exc); } // Release the permit. System.out.println(threadName + ':Released the permit'); sem.release(); } // Thread T2 processing else { System.out.println('Start: ' + threadName); try { System.out.println(threadName + ':waiting for a permit.'); // acquire the lock sem.acquire(); System.out.println(threadName + ':Acquired permit'); // process the shared resource for(int i=0; i < 5; i++) { SharedRes.count--; System.out.println(threadName + ': ' + SharedRes.count); Thread.sleep(10); } } catch (InterruptedException exc) { System.out.println(exc); } // Release the permit. System.out.println(threadName + ':Released the permit.'); sem.release(); } } } public class Main { public static void main(String args()) throws InterruptedException { //create Semaphore=> #permits = 1 Semaphore sem = new Semaphore(1); // Create thread instances T1 & T2 //T1=> Increments the count; T2=> Decrements the count ThreadClass thread1 = new ThreadClass(sem, 'T1'); ThreadClass thread2 = new ThreadClass(sem, 'T2'); // start T1 & T2 thread1.start(); thread2.start(); // Wait T1 & T2 thread1.join(); thread2.join(); System.out.println('count: ' + SharedRes.count); // display final count. } }

Оутпут

излаз - Семафор на Јави

Овај програм је прогласио класу за дељени ресурс. Такође декларише класу нити у којој имамо променљиву семафора која је иницијализована у конструктору класе.

У методи оверридден рун () класе Тхреад врши се обрада инстанце нити у којој нит добија дозволу, приступа дељеном ресурсу, а затим издаје дозволу.

У главној методи смо прогласили две инстанце нити. Затим се покрећу обе нити, а затим чекају помоћу методе спајања. На крају се приказује бројање, тј. 0, што значи да су обе нити завршиле са дељеним ресурсом.

ц ++ генерише случајни број између 0 и 1

Форк анд Јоин Ин Јава

Оквир форк / јоин је први пут представљен у Јави 7. Овај оквир се састоји од алата који могу убрзати паралелну обраду. Користи сва доступна процесорска језгра у систему и довршава задатак. Оквир форк / јоин користи приступ подели и освоји.

Основна идеја која стоји иза оквира Форк / Јоин је да први оквир „Форкс“, тј. Рекурзивно раставља задатак на мање појединачне подзадатке док задаци не постану атомски, тако да се могу извршавати асинхроно.

Након тога, задаци се „спајају“, тј. Сви подзадаци се рекурзивно спајају у један задатак или повратну вредност.

Оквир форк / јоин има скуп нити познатих као „ФоркЈоинПоол“. Овај базен управља радним нитима „ФоркЈоинВоркерТхреад“, пружајући тако ефикасну паралелну обраду.

ФоркЈоинПоол управља радним нитима и такође нам помаже да добијемо информације у вези са перформансама и стањем спремишта нити. ФоркЈоинПоол је примена „ЕкецуторСервице“ о којој смо горе говорили.

За разлику од радничких нити, ФоркЈоинПоол не ствара засебну нит за сваки подзадатак. Свака нит у ФоркЈоинПоол одржава свој декуе (двоструки ред) за чување задатака.

Декуе делује као балансирање радног оптерећења нити и то чини уз помоћ „алгоритма за крађу рада“ који је описан у наставку.

Алгоритам крађе посла

Алгоритам крађе рада можемо одредити једноставним речима као „Ако је нит слободна,’ украдите ’посао из заузетих нити“.

Радничка нит ће задатке увек добијати из свог декуе-а. Када су сви задаци у декуеу исцрпљени, а декуе празан, радничка нит ће преузети задатак из репа другог декуе-а или из „глобалног реда уноса“.

На овај начин је смањена могућност надметања нити за задатке, а смањен је и број пута који нит треба да тражи за посао. То је зато што је нит већ добила највећи део доступног посла и завршила је.

Па како можемо да користимо ФоркЈоинПоол у ​​програму?

Општа дефиниција ФоркЈоинПоол је следећа:

public class ForkJoinPool extends AbstractExecutorService

Класа ФоркЈоинПоол је део пакета „јава.утил.цонцуррент“.

У Јави 8 креирамо инстанцу ФоркЈоинПоол-а користећи његову статичку методу „цоммон-поол ()“ која пружа референцу на заједнички базен или подразумевано спремиште нити.

ForkJoinPool commonPool = ForkJoinPool.commonPool ();

У Јави 7 креирамо инстанцу ФоркЈоинПоол и додељујемо је пољу класе услужних програма као што је приказано доле.

public static ForkJoinPool forkJoinPool = new ForkJoinPool(2);

Горња дефиниција указује на то да спремиште има ниво паралелизма 2 такав да ће пулс користити 2 процесорска језгра.

Да бисмо приступили горњем базену, можемо дати следећу изјаву.

ForkJoinPool forkJoinPool = PoolUtil.forkJoinPool;

Основни тип за задатке ФоркЈоинПоол је „ФоркЈоинТаск“. Требали бисмо проширити једну од његових поткласа, тј. За воид задатке, РецурсивеАцтион и за задатке који враћају вредност, РецурсивеТаск. Обе проширене класе пружају апстрактну методу цомпуте () у којој дефинишемо логику задатка.

Следећи пример је пример за демонстрирање ФоркЈоинПоол-а.

import java.util.ArrayList; import java.util.List; import java.util.concurrent.*; //class declaration for ForkJoinPool tasks class FJPoolTask extends RecursiveAction { private long Load = 0; public FJPoolTask(long Load) { this.Load = Load; } @Override protected void compute() { //if threshold is reached, break tasks into smaller tasks List subtasks = new ArrayList(); subtasks.addAll(createSubtasks()); for(RecursiveAction subtask : subtasks){ subtask.fork(); } } //create subtasks private List createSubtasks() { List sub_tasks =new ArrayList(); FJPoolTask sub_task1 = new FJPoolTask(this.Load / 2); FJPoolTask sub_task2 = new FJPoolTask(this.Load / 2); FJPoolTask sub_task3 = new FJPoolTask(this.Load / 2); sub_tasks.add(sub_task1); sub_tasks.add(sub_task2); sub_tasks.add(sub_task3); return sub_tasks; } } public class Main { public static void main(final String() arguments) throws InterruptedException { //get count of available processors int proc = Runtime.getRuntime().availableProcessors(); System.out.println('Processors available:' +proc); //declare forkJoinPool ForkJoinPool Pool = ForkJoinPool.commonPool(); System.out.println(' Active Threads (Before invoke):' +Pool.getActiveThreadCount()); //Declare ForkJoinPool task object FJPoolTask t = new FJPoolTask(400); //submit the tasks to the pool Pool.invoke(t); System.out.println(' Active Threads (after invoke):' +Pool.getActiveThreadCount()); System.out.println('Common Pool Size :' +Pool.getPoolSize()); } }

Оутпут

излаз - ФоркЈоинПоол

У горњем програму проналазимо број активних нити у систему пре и после позива методе „инвоке ()“. Метода инвоке () користи се за предавање задатака спремишту. Такође проналазимо број доступних процесорских језгара у систему.

Често постављана питања

П # 1) Шта је истовремено Јава Утил?

Одговор: Пакет „јава.утил.цонцуррент“ је скуп класа и интерфејса које пружа Јава за олакшавање развоја истовремених (вишенитних) апликација. Коришћењем овог пакета можемо директно користити интерфејс и класе, као и АПИ-је, а да не морамо писати наше класе.

П # 2) Које од следећег су истовремене имплементације присутне у јава.утил. паралелни пакет?

Одговор: На високом нивоу, пакет јава.утил.цонцуррент садржи услужне програме као што су Извршитељи, Синхронизатори, Редови чекања, Истовремене колекције.

П # 3) Шта је будућа Јава?

Одговор: Будући објекат (јава.утил.цонцуррент.Футуре) користи се за чување резултата које враћа нит када је имплементиран интерфејс Цаллабле.

П # 4) Шта је у Јава-и безбедно за нит?

Одговор: Код или класа безбедни за нит у Јави је код или класа који се могу без проблема делити у вишенитном или истовременом окружењу и дају очекиване резултате.

П # 5) Шта је синхронизована колекција у Јави?

Одговор: Синхронизована колекција је колекција безбедна за нит. Метода синхронизована колекција () класе јава.утил.Цоллецтионс враћа синхронизовану (нит-сафе) колекцију.

Закључак

Овим упутством завршили смо тему вишеструког навоја и истовремености у Јави. О мултитхреадинг-у смо детаљно разговарали у нашим претходним водичима. Овде смо разговарали о паралелности и имплементацији везаној за паралелност и мултитхреадинг који су део пакета јава.утил.цонцуррент.

Разговарали смо о још две методе синхронизације, семафорима и РеентрантЛоцк-у. Такође смо разговарали о ФоркЈоинПоол-у који се користи за извршавање задатака тако што их је поделио на једноставније задатке и на крају придружио резултат.

Пакет јава.утил.цонцуррент такође подржава Екецутор фрамеворк и извршитеље који нам помажу у извршавању нити. Такође смо разговарали о имплементацији спремишта нити која се састоји од нити за вишекратну употребу које се враћају у спремиште када је извршење завршено.

Разговарали смо о другом интерфејсу сличном Руннабле-у који нам такође помаже да вратимо резултат из нити и објекат Футуре који се користи за чување добијеног резултата нити.

=> Овде припазите на једноставну серију Јава тренинга.

Препоручено читање

^