Kapag bumubuo ng isang multi-threaded na application, kadalasan ay dapat nating harapin ang pag-aayos ng gawain ng mga thread. Kung mas malaki ang aming application at mas maraming thread na kailangan namin para sa mga multithreaded na gawain, mas maramiRunnablemga bagay na ating nilikha.

Dapat pansinin dito na ang paglikha ng isang thread sa Java ay isang medyo mahal na operasyon. Kung gagawa kami ng bagong instance ng thread sa bawat oras na magsagawa ng operasyon, magkakaroon kami ng malalaking problema sa performance at, bilang resulta, sa kalusugan ng application.

Isang thread pool at ThreadPoolExecutor ang tumulong sa amin dito.

Ang thread pool ay isang set ng mga paunang inisyal na thread. Ang laki nito ay maaaring maayos o variable.

Kung may mas maraming gawain kaysa sa mga thread, maghihintay ang mga gawain sa isang pila ng gawain. Ang Nth thread sa pool ay kumukuha ng gawain mula sa queue, at pagkatapos nito, kukuha ang thread ng bagong gawain mula sa queue. Kapag ang lahat ng mga gawain sa pila ay naisakatuparan, ang mga thread ay mananatiling aktibo at naghihintay para sa mga bagong gawain. Kapag lumitaw ang mga bagong gawain, magsisimula rin ang mga thread na isagawa ang mga ito.

ThreadPoolExecutor

Java university

Simula sa Java 5, ang Executor framework ay nakakuha ng multithreading solution. Sa pangkalahatan, marami itong bahagi at ang layunin nito ay tulungan kaming mahusay na pamahalaan ang mga pila at thread pool.

Ang mga pangunahing interface ay Executor at ExecutorService .

Ang Executor ay isang interface na may iisang void execute(Runnable runnable) na paraan.

Kapag nagpapasa ng isang gawain sa isang pagpapatupad ng paraang ito, alamin na ito ay isasagawa nang asynchronous sa hinaharap.

ExecutorService — Isang interface na nagpapalawak ng interface ng Executor , nagdaragdag ng mga kakayahan para sa pagpapatupad ng mga gawain. Mayroon din itong mga pamamaraan para sa pag-abala sa isang tumatakbong gawain at pagwawakas sa thread pool.

Ipinapatupad ng ThreadPoolExecutor ang mga interface ng Executor at ExecutorService at pinaghihiwalay ang paggawa ng gawain mula sa pagpapatupad ng gawain. Kailangan nating ipatupad ang mga Runnable na bagay at ipadala ang mga ito sa isang executor. Ang ThreadPoolExecutor ay responsable sa pagpapatupad ng mga gawain, at paggawa at pagtatrabaho sa mga thread.

Pagkatapos maipadala ang isang gawain para sa pagpapatupad, isang umiiral na thread sa pool ang ginagamit. Pinapabuti nito ang pagganap. Nilulutas nito ang problema sa pag-aaksaya ng mga mapagkukunan sa paggawa at pagsisimula ng bagong thread, at pagkatapos ay muli sa pangongolekta ng basura kapag tapos na tayo sa thread.

Ang ThreadPoolExecutor ay may 4 na konstruktor:


ThreadPoolExecutor(
int corePoolSize,
int maximumPoolSize,
long keepAliveTime, 
TimeUnit unit, 
BlockingQueue<Runnable> workQueue)
    

ThreadPoolExecutor(
int corePoolSize,
int maximumPoolSize,
long keepAliveTime,
TimeUnit unit,
BlockingQueue<Runnable> workQueue,
RejectedExecutionHandler handler)
    

ThreadPoolExecutor(
int corePoolSize,
int maximumPoolSize,
long keepAliveTime, 
TimeUnit unit,
BlockingQueue<Runnable> workQueue,
ThreadFactory threadFactory)
    

ThreadPoolExecutor(
int corePoolSize,
int maximumPoolSize,
long keepAliveTime, 
TimeUnit unit,
BlockingQueue<Runnable> workQueue,
ThreadFactory threadFactory, 
RejectedExecutionHandler handler)

Ang ThreadPoolExecutor constructor ay may mga sumusunod na parameter:

corePoolSize Ang parameter na ito ay nagpapahiwatig kung gaano karaming mga thread ang magiging handa (nagsisimula) kapag nagsimula ang serbisyo ng tagapagpatupad.
maximumPoolSize Ang maximum na bilang ng mga thread na maaaring gawin ng isang executor service.
keepAliveTime Ang oras na ang isang napalayang thread ay patuloy na mabubuhay bago masira kung ang bilang ng mga thread ay mas malaki kaysa sacorePoolSize. Ang mga yunit ng oras ay tinukoy sa susunod na parameter.
yunit Mga yunit ng oras (oras, minuto, segundo, millisecond, atbp.).
workQueue Pagpapatupad ng isang pila para sa mga gawain.
handler Handler para sa mga gawaing hindi matatapos.
threadFactory Isang bagay na lumilikha ng mga bagong thread on demand. Ang paggamit ng mga pabrika ng thread ay gumagawa ng mga tawag sa isang bagong thread na hardware na independyente, na nagpapahintulot sa mga application na gumamit ng mga espesyal na subclass ng thread, mga priyoridad, at iba pa.

Paglikha ng ThreadPoolExecutor

Ang klase ng utility ng Executors ay maaaring gawing simple ang paglikha ng isang ThreadPoolExecutor . Ang mga pamamaraan ng utility class na ito ay tumutulong sa amin na maghanda ng aThreadPoolExecutorbagay.

newFixedThreadPool — Lumilikha ng thread pool na muling gumagamit ng isang nakapirming bilang ng mga thread upang magsagawa ng anumang bilang ng mga gawain. 

ExecutorService executor = Executors.newFixedThreadPool(10);
newWorkStealingPool — Lumilikha ng thread pool kung saan ang bilang ng mga thread ay katumbas ng bilang ng mga processor core na available sa JVM. Ang default na antas ng concurrency ay isa. Nangangahulugan ito na kasing dami ng mga thread ang gagawin sa pool dahil may mga CPU core na available sa JVM. Kung ang concurrency level ay 4, ang ipinasa na halaga ang gagamitin sa halip na ang bilang ng mga core. 

ExecutorService executor = Executors.newWorkStealingPool(4);
newSingleThreadExecutor — Lumilikha ng pool na may iisang thread para isagawa ang lahat ng gawain. 

ExecutorService executor = Executors.newSingleThreadExecutor();
newCachedThreadPool — Lumilikha ng thread pool na gumagawa ng mga bagong thread kung kinakailangan, ngunit muling ginagamit ang mga naunang ginawang thread kapag available ang mga ito. 

ExecutorService executor = Executors.newCachedThreadPool();
newScheduledThreadPool — Lumilikha ng thread pool na maaaring mag-iskedyul ng mga command na isasagawa pagkatapos ng isang naibigay na pagkaantala o pana-panahon. 

ScheduledExecutorService executor = Executors.newScheduledThreadPool(10);

Isasaalang-alang natin ang bawat uri ng pool sa mga sumusunod na aralin.