ThreadPoolExecutor

"Ang mga ordinaryong programmer ay maaga o huli ay naiintindihan ang katotohanan na mayroon silang maraming maliliit na gawain na kailangang gawin paminsan-minsan."

"Kung nagsusulat ka ng isang laro, kung gayon ito ang mga aksyon na ginagawa ng mga indibidwal na character."

"Kung nagsusulat ka ng isang web server, iba't ibang mga utos ang nanggagaling sa mga user: mag-upload ng larawan, i-transcode ito sa gustong format, ilapat ang gustong template, atbp."

"Maaga o huli, ang lahat ng malalaking gawain ay nahahati sa isang hanay ng maliliit, mapapamahalaang gawain."

"Kaya, dahil sa kontekstong ito, lumitaw ang isang banayad na tanong: paano mo dapat pangasiwaan ang lahat ng ito? Paano kung kailangan mong magsagawa ng ilang daang gawain sa isang minuto? Ang paglikha ng isang thread para sa bawat gawain ay hindi magiging makabuluhan. Ang Java machine naglalaan ng napakaraming mapagkukunan para sa bawat thread."

"Sa madaling salita, ang paggawa at pagsira sa isang thread ay maaaring tumagal ng mas maraming oras at mapagkukunan kaysa sa mismong gawain."

"Ang mga tagalikha ng Java ay nakabuo ng isang eleganteng solusyon sa problemang ito: ThreadPoolExecutor .

" Ang ThreadPoolExecutor ay isang klase na may dalawang bagay sa loob:"

A)  Isang pila ng gawain, kung saan maaari mong idagdag ang gawain kapag lumitaw ang mga ito sa programa.

B) Isang thread pool, na isang pangkat ng mga thread na nagsasagawa ng mga gawaing ito.

"Higit pa rito, hindi nasisira ang mga thread kapag natapos na ang isang gawain. Sa halip, natutulog sila upang maging handa na magsimula ng bagong gawain sa sandaling lumitaw ito."

"Kapag lumikha ka ng ThreadPoolExecutor , maaari mong itakda ang maximum na bilang ng mga thread na gagawin at ang maximum na bilang ng mga gawain na maaaring i-queue. Sa madaling salita, maaari mong limitahan ang bilang ng mga thread sa 10, halimbawa, at ang bilang ng nakapila ang mga gawain sa 100."

"Ganito gumagana ang ThreadPoolExecutor :"

1)  Kapag nagdagdag ka ng bagong gawain, inilalagay ito sa dulo ng pila.

2)  Kung puno na ang pila, may itatapon na exception.

3)  Sa pagkumpleto ng isang gawain, ang bawat thread ay kukuha ng susunod na gawain mula sa pila at magsisimulang isagawa ito.

4) Kung walang mga gawain sa pila, matutulog ang isang thread hanggang sa maidagdag ang mga bagong gawain.

"Ang diskarte, kung saan nililimitahan namin ang bilang ng mga thread ng manggagawa, ay kapaki-pakinabang dahil sa mas maraming mga thread na mayroon kami, mas nakakasagabal ang mga ito sa isa't isa. Mas epektibong magkaroon ng 5-10 thread ng manggagawa at mahabang pila ng mga gawain kaysa sa upang lumikha ng 100 mga thread para sa isang surge ng mga gawain, na makipagkumpitensya sa isa't isa para sa mga mapagkukunan: memorya, oras ng processor, pag-access sa database, atbp."

"Narito ang isang halimbawa ng ThreadPoolExecutor na kumikilos:"

ExecutorService service = Executors.newFixedThreadPool(2);

for(int i = 0; i < 10; i++)
{
 service.submit(new Runnable() {
    public void run()
    {
     // Here we download something big from the Internet.
    }
 });
}

"Uh, hindi ko nakikita..."

"Ang isang bagay na ThreadPoolExecutor ay nilikha kapag ang bagong FixedThreadPool na pamamaraan ay tinawag."

Kaya, napakadaling gamitin. Sa sandaling magdagdag ka ng isang gawain dito gamit ang paraan ng pagsusumite, ito ay:

A)  Gumising ng natutulog na thread, kung mayroon man, upang maisagawa ang gawain.

B)  Kung walang naghihintay na thread, lilikha ito ng bago para sa gawain.

C)  Kung ang maximum na bilang ng mga thread ay naabot, pagkatapos ay inilalagay lamang nito ang gawain sa dulo ng pila.

"Sinadya kong isinama ang «dito nagda-download kami ng isang bagay na malaki mula sa Internet» sa halimbawa. Kung mayroon kaming 100 mga gawain «mag-download ng isang bagay na malaki mula sa Internet», kung gayon walang saysay na patakbuhin ang marami sa kanila nang sabay-sabay—kami' Pipigilan ng limitasyon ng bandwidth ng aming koneksyon sa Internet. Sa kasong ito, sapat na ang ilang thread. Ito ang nakikita mo sa halimbawa sa itaas:"

ExecutorService service = Executors.newFixedThreadPool(2);

"Lumalabas na ang pagtatrabaho sa isang bungkos ng mga gawain ay hindi napakahirap."

"Oo. Kahit na mas madali kaysa sa maaari mong isipin. Pero sasabihin sa iyo ni Kim ang tungkol doon."