Artikulo
Magsimula
Simulan ang pag-aaral
JavaRush /Java Blog /Random-TL /Pagsasalin: Nangungunang 50 tanong sa panayam ayon sa thr...
KapChook
Antas
Volga

Pagsasalin: Nangungunang 50 tanong sa panayam ayon sa thread. Bahagi 2.

Nai-publish sa grupo
Java-университет
Ang ikalawang bahagi ng pagsasalin ng orihinal na artikulo Top 50 Java Thread Interview Questions Answers for Freshers, Experienced Programmer. Unang parte.

  1. Paano suriin kung ang isang thread ay may hawak na lock?

    2. Wala akong ideya na maaari mong suriin kung ang isang thread ay kasalukuyang may hawak na lock hanggang sa makita ko ang tanong na ito sa isang panayam sa telepono. Ang java.lang.Thread ay mayroong paraan ng holdsLock(), ito ay nagbabalik ng true kung at kung ang kasalukuyang thread ay humahawak sa monitor sa isang partikular na bagay.

  2. Paano kumuha ng thread dump?

    3. Nagbibigay-daan sa iyo ang isang thread dump na malaman kung ano ang kasalukuyang ginagawa ng isang thread. Mayroong ilang mga paraan upang makakuha ng isang thread dump, depende sa operating system. Sa Windows maaari mong gamitin ang kumbinasyon na ctrl + Break, sa Linux maaari mong gamitin ang kill -3 command. Maaari mo ring gamitin ang jstack utility; ito ay gumagana sa process id, na maaari mong malaman gamit ang isa pang jps utility.

  3. Anong parameter ng JVM ang ginagamit upang kontrolin ang laki ng stack ng thread?

    4. Isa ito sa simple, -Xss na parameter na ginagamit upang kontrolin ang laki ng stack ng thread sa Java.

  4. Mga pagkakaiba sa pagitan ng naka-synchronize at ReentrantLock?

    5. May mga pagkakataon na ang tanging paraan upang makamit ang kapwa pagbubukod ay sa pamamagitan ng naka-synchronize na keyword, ngunit mayroon itong ilang mga disadvantages, tulad ng hindi ma-extend ang lock nang lampas sa isang paraan o block ng code, atbp. Niresolba ng Java 5 ang problemang ito sa pamamagitan ng pagbibigay ng higit pang butil na kontrol sa pamamagitan ng interface ng Lock. Ang ReentrantLock ay isang karaniwang pagpapatupad ng Lock na nagbibigay ng Lock na may parehong pangunahing gawi at semantika bilang isang implicit na monitor, na nakamit gamit ang mga naka-synchronize na pamamaraan, ngunit may mga pinahusay na kakayahan.

  5. Nabigyan ng 3 thread T1, T2 at T3? Paano ipatupad ang pagkakasunud-sunod na T1, T2, T3?

    6. Ang pagkakapare-pareho ay maaaring makamit sa maraming paraan, ngunit maaari mo lamang gamitin ang join() na paraan upang simulan ang isang thread kapag ang isa pa ay tapos nang mag-execute. Upang ipatupad ang ibinigay na pagkakasunud-sunod, kailangan mong simulan muna ang huling thread, at pagkatapos ay tawagan ang join() na paraan sa reverse order, iyon ay, T3 ay tumatawag sa T2.join at T2 ay tumatawag sa T1.join, kaya ang T1 ay matatapos muna at T3 ang huli. .

  6. Ano ang ginagawa ng yield method?

    7. Ang paraan ng pagbubunga ay isang paraan upang hilingin sa isang thread na isuko ang CPU upang ang isa pang thread ay makapagpatupad. Ito ay isang static na pamamaraan at tinitiyak lamang nito na ang kasalukuyang thread ay ibibigay ang processor, ngunit hindi magpapasya kung aling thread execution ang mapupunta.

  7. Ano ang antas ng concurrency ng ConcurrentHashMap?

    8. Nakakamit ng ConcurrentHashMap ang scalability at kaligtasan ng thread sa pamamagitan ng paghahati sa aktwal na mapa sa mga seksyon. Ang paghihiwalay na ito ay nakakamit sa pamamagitan ng paggamit ng antas ng paralelismo. Isa itong opsyonal na parameter sa ConcurrentHashMap constructor at ang default na value nito ay 16.

  8. Ano ang Semaphore?

    9. Ang Semaphore ay isang bagong uri ng synchronizer. Ito ay isang semaphore na may counter. Sa konsepto, kinokontrol ng isang semaphore ang isang hanay ng mga pahintulot. Bawat acquire() block, kung kinakailangan, bago makuha ang pahintulot, pagkatapos ay makuha ito. Ang bawat release() ay nagdaragdag ng pahintulot, na posibleng ilabas ang blocking acquirer. Gayunpaman, hindi ito gumagamit ng aktwal na mga bagay ng pahintulot; Iniimbak lamang ng Semaphore ang bilang ng mga magagamit at kumikilos nang naaayon. Ginagamit ang Semaphore upang protektahan ang mga mamahaling mapagkukunan na magagamit sa limitadong dami, tulad ng isang koneksyon sa isang pinagsama-samang database.

  9. Ano ang mangyayari kung puno na ang thread pool queue at nagsumite ka ng gawain?

    10. Kung puno na ang thread pool queue, "reject" ang isinumiteng gawain. Ang pamamaraan ng submit() ng ThreadPoolExecutor ay naghagis ng RejectedExecutionException, pagkatapos ay tinawag ang RejectedExecutionHandler.

  10. Mga pagkakaiba sa pagitan ng submit() at execute() na mga pamamaraan sa isang thread pool?

    11. Ang parehong mga pamamaraan ay mga paraan ng pagsusumite ng isang gawain sa isang thread pool, ngunit may kaunting pagkakaiba sa pagitan ng mga ito. Ang Execute(Runnable command) ay tinukoy sa interface ng Executor at nagsasagawa ng ibinigay na gawain sa hinaharap, ngunit higit sa lahat, hindi nagbabalik ng anuman. Sa kabilang banda, ang submit() ay isang overloaded na paraan, maaari itong tumanggap ng Runnable at Callable na mga gawain at maaaring magbalik ng Future object na magagamit para kanselahin ang execution at/o maghintay para sa resulta ng isang kalkulasyon. Ang pamamaraang ito ay tinukoy sa interface ng ExecutorService, na nagmamana mula sa interface ng Executor, at ang bawat thread pool class, gaya ng ThreadPoolExecutor o ScheduledThreadPoolExecutor, ay nagmamana ng mga pamamaraang ito.

  11. Ano ang paraan ng pagharang?

    12. Ang paraan ng pagharang ay isang paraan na humaharang hanggang sa makumpleto ang gawain, halimbawa, ang ServerSocket accept() na paraan ay humaharang habang naghihintay na kumonekta ang kliyente. Dito, ang pag-block ay nangangahulugan na ang kontrol ay hindi babalik sa paraan ng pagtawag hanggang sa makumpleto ang trabaho. Sa kabilang banda, may mga asynchronous o non-blocking na pamamaraan na kumpletuhin bago matapos ang gawain.

  12. Ligtas ba ang Swing thread?

    13. Sa madaling salita, hindi, hindi thread-safe ang Swing, ngunit kailangan mong ipaliwanag kung ano ang ibig mong sabihin doon, kahit na hindi nagtatanong ang tagapanayam. Kapag sinabi namin na ang Swing ay hindi thread-safe, karaniwan naming tinutukoy ang katotohanan na ito ay isang bahagi na hindi maaaring baguhin ng maraming mga thread. Ang lahat ng mga pagbabago sa mga bahagi ng GUI ay dapat gawin sa AWT thread, at ang Swing ay nagbibigay ng mga kasabay at asynchronous na pamamaraan para sa pag-iskedyul ng mga naturang pagbabago.

  13. Mga pagkakaiba sa pagitan ng invokeAndWait at invokeLater?

    14. Ito ay dalawang pamamaraan ng Swing API na nagbibigay-daan sa mga developer na i-update ang mga bahagi ng GUI mula sa mga thread sa halip na mula sa thread ng Event Manager. Ang InvokeAndWait() ay sabay-sabay na nag-a-update ng isang bahagi ng GUI tulad ng isang progress bar; sa bawat oras na may pag-unlad, dapat na i-update ang bar upang ipakita ang mga pagbabago. Kung sinusubaybayan ang progreso sa isa pang thread, dapat itong tumawag sa invokeAndWait() para italaga ang Event Dispatcher thread para i-update ang bahaging iyon. At ang invokeLater() ay isang asynchronous na tawag upang i-update ang mga bahagi.

  14. Aling mga pamamaraan ng Swing API ang ligtas sa thread?

    15. Ang tanong na ito ay muli tungkol sa Swing at kaligtasan ng thread, bagaman ang mga bahagi ng Swing ay hindi ligtas sa thread, may mga pamamaraan na maaaring ligtas na tawagan mula sa maraming mga thread. Alam ko na ang repaint() at revalidate() ay thread-safe, ngunit may iba pang mga pamamaraan sa iba't ibang bahagi ng Swing, tulad ng JTextComponent's setText() at JTextArea's insert() at append() na mga pamamaraan.

  15. Paano lumikha ng mga hindi nababagong bagay?

    16. Ang tanong na ito ay maaaring mukhang walang kinalaman sa multithreading at concurrency, ngunit ginagawa nito. Ang kawalan ng pagbabago ay nakakatulong na gawing simple ang kumplikadong parallel code. Ang isang hindi nababagong bagay ay napakamahal para sa mga developer dahil maaari itong ipalaganap nang walang anumang pag-synchronize. Sa kasamaang palad, walang @Immutable annotation ang Java, na gagawing hindi nababago ang iyong object, dahil kailangan ng mga developer na magtrabaho nang husto. Upang lumikha ng isang hindi nababagong bagay, kailangan mong sundin ang mga pangunahing kaalaman: pagsisimula sa constructor, walang setter, walang reference na pagtagas, pag-iimbak ng hiwalay na mga kopya ng mga nababagong bagay.

  16. Ano ang ReadWriteLock?

    17. Sa pangkalahatan, ang ReadWriteLock ay resulta ng isang lock parsing technique upang mapabuti ang pagganap ng mga parallel na application. Ito ay isang interface na idinagdag sa Java 5. Ito ay gumagana sa isang pares ng mga kaugnay na lock, isa para sa read operations, isa para sa write operations. Ang isang reader lock ay maaaring hawakan nang sabay-sabay ng ilang mga thread sa pagbabasa hanggang sa walang mga manunulat. Eksklusibo ang writing lock. Kung gusto mo, maaari kang magpatupad ng interface sa iyong ruleset, o maaari mong gamitin ang ReentrantReadWriteLock, na sumusuporta sa maximum na 65535 recursive write lock at 65535 read lock.

  17. Ano ang busy spin?

    18. Ang Busy Spin ay isang pamamaraan na ginagamit ng mga programmer upang pilitin ang isang thread na maghintay sa ilalim ng isang partikular na kundisyon. Hindi tulad ng mga tradisyunal na pamamaraan, wait(), sleep() o yield(), na kinasasangkutan ng ceding control ng processor, hindi isinusuko ng pamamaraang ito ang processor; sa halip, nagsasagawa lamang ito ng walang laman na loop. Bakit may gagawa nito? Upang i-save ang cache ng processor. Sa mga multi-core system, posible na ang isang nasuspinde na thread ay magpapatuloy sa pagpapatupad sa isa pang core, na nangangahulugang isang muling pagtatayo ng cache. Upang maiwasan ang magastos na muling pagtatayo, mas pinipili ng programmer na maghintay nang mas kaunti sa pamamagitan ng paggamit ng busy spin.

  18. Mga pagkakaiba sa pagitan ng pabagu-bago ng isip at atomic variable?

    19. Ito ay medyo isang kawili-wiling tanong, sa una pabagu-bago at atomic na mga variable ay mukhang magkatulad, ngunit sila ay naiiba pa rin. Ang isang volatile variable ay nagbibigay ng happens-before na garantiya na ang isang pagsulat ay magaganap bago ang anumang kasunod na pagsusulat; hindi nito ginagarantiyahan ang atomicity. Halimbawa, ang pagpapatakbo ng count++ ay hindi magiging atomic dahil lamang ang bilang ay idineklara na pabagu-bago. Sa kabilang banda, ang klase ng AtomicInteger ay nagbibigay ng isang atomic na paraan upang maisagawa ang mga ganitong kumplikadong operasyon nang atomiko, halimbawa ang getAndIncrement() ay isang atomic na kapalit para sa increment operator, maaari itong magamit upang atomically dagdagan ang kasalukuyang halaga ng isa. Mayroon ding mga atomic na bersyon para sa iba pang mga uri ng data.

  19. Ano ang mangyayari kung ang isang thread ay naghagis ng Exception sa isang naka-synchronize na bloke?

    20. Ito ay isa pang tanong ng trick para sa mga regular na programmer ng Java. Hindi mahalaga kung paano ka lumabas sa isang naka-synchronize na bloke, alinman sa karaniwan sa pamamagitan ng pagtatapos ng pagpapatupad o biglaan sa pamamagitan ng paghahagis ng exception, ilalabas ng thread ang nakuhang lock kapag pumasok ito sa naka-synchronize na bloke. Ito ang isa sa mga dahilan kung bakit mas gusto ko ang isang naka-synchronize na bloke ng lock kaysa sa isang interface na nangangailangan ng espesyal na pangangalaga kapag nilalabas ang lock, kadalasang nakakamit sa pamamagitan ng paglalabas ng lock sa isang block sa wakas.

  20. Ano ang double checked locking ng Singleton?

    21. Ito ay isa sa mga pinakasikat na tanong sa panayam, at gayunpaman, sa kabila ng katanyagan nito, ang mga pagkakataon ng isang kandidato na sumagot dito ay 50% sa pinakamahusay. Kalahati ng oras na nabigo sila sa pagsulat ng code, at ang kalahati sa pagpapaliwanag kung paano ito nasira at naayos sa Java 1.5. Ito ay isang lumang paraan ng paglikha ng isang thread-safe singleton na sumusubok na i-optimize ang pagganap sa pamamagitan lamang ng pagharang kapag ang singleton instance ay unang na-instantiate, ngunit dahil sa pagiging kumplikado at ang katotohanan na ito ay nasira sa JDK 1.4, ako mismo ay hindi gusto ito. Gayunpaman, kahit na hindi mo ginusto ang diskarteng ito, kapaki-pakinabang na malaman ito mula sa isang pananaw sa pakikipanayam.

  21. Paano lumikha ng isang thread-safe na Singleton?

    22. Ang tanong na ito ay umakma sa nauna. Kung sasabihin mong hindi mo gusto ang pag-double check na pag-lock, mapipilitan ang tagapanayam na magtanong tungkol sa mga alternatibong paraan upang lumikha ng Singleton na ligtas sa thread. At ang mga ito ay, maaari mong samantalahin ang pag-load ng klase at mga tampok na static na variable initialization upang ma-instantiate ang Singleton, o maaari mong samantalahin ang malakas na uri ng enum.

  22. Maglista ng 3 kaugalian na sinusunod mo sa parallel programming?

    23. Ito ang paborito kong tanong dahil naniniwala akong may ilang partikular na panuntunan na kailangang sundin kapag nagsusulat ng parallel code, na nakakatulong sa pagganap, pag-debug, at suporta. Nasa ibaba ang 3 pinakamahusay na panuntunan na pinaniniwalaan kong dapat sundin ng bawat Java programmer:
    • Laging magbigay ng makabuluhang pangalan sa iyong mga thread
      • Ang paghahanap ng bug o pagsubaybay sa isang exception sa parallel code ay medyo mahirap na gawain. Ang OrderProcessor, QuoteProcessor o TradeProcessor ay mas mahusay kaysa sa Thread-1. Thread-2 at Thread-3. Dapat ipakita ng pangalan ang gawaing ginagawa ng thread. Ang lahat ng pangunahing balangkas at maging ang JDK ay sumusunod sa panuntunang ito.
    • Iwasan ang pagharang o bawasan ang saklaw ng pag-sync
      • Mahal ang pag-block, at mas mahal ang paglipat ng konteksto. Subukang iwasan ang pag-synchronize at pagharang hangga't maaari, at babawasan mo ang kritikal na seksyon sa minimum na kinakailangan. Ito ang dahilan kung bakit mas gusto ko ang isang naka-time na bloke kaysa sa isang naka-time na paraan dahil binibigyan ka nito ng ganap na kontrol sa lawak ng pagharang.
    • Sa pagitan ng mga synchronizer at maghintay at mag-notify, pumili ng mga synchronizer
      • Una, pinapasimple ng mga synchronizer gaya ng CountDownLatch, Semaphore, CyclicBarrier o Exchanger ang coding. Napakahirap ipatupad ang kumplikadong daloy ng kontrol gamit ang wait and notify. Pangalawa, ang mga klase na ito ay isinulat at pinapanatili ng pinakamahusay sa negosyo at may magandang pagkakataon na ang mga ito ay ma-optimize o mapapalitan ng mas magandang code sa hinaharap na mga release ng JDK. Sa pamamagitan ng paggamit ng mga high-level na kagamitan sa pag-synchronize, awtomatiko mong makukuha ang lahat ng mga benepisyong ito.
    • Sa pagitan ng Kasabay na Koleksyon at Naka-synchronize na Koleksyon, piliin ang Kasabay na Koleksyon
      • Ito ay isa pang simpleng tuntunin na madaling sundin at anihin ang mga benepisyo. Ang mga sabay-sabay na koleksyon ay mas nasusukat kaysa sa kanilang mga naka-synchronize na katapat, kaya mas mainam na gamitin ang mga ito kapag nagsusulat ng parallel code. Kaya sa susunod na kailangan mo ng mapa, isipin ang ConcurrentHashMap bago mo isipin ang Hashtable.

  23. Paano pilitin na magsimula ang isang thread?

    24. Ito ay isang tanong a la kung paano pilitin na tumakbo ang koleksyon ng basura. Sa madaling salita, walang paraan, maaari kang gumawa ng isang query gamit ang System.gc(), ngunit hindi nito ginagarantiyahan ang anuman. Walang ganap na paraan upang pilitin ang isang thread na magsimula sa Java, ito ay kinokontrol ng thread scheduler at ang Java ay hindi nagbibigay ng anumang API upang kontrolin ito. Ang bahaging ito ng Java ay random pa rin.

  24. Ano ang Fork/Join framework?

    25. Ang Fork/Join framework na ipinakilala sa JDK 7 ay isang makapangyarihang utility na nagbibigay-daan sa developer na samantalahin ang maraming processor ng mga modernong server. Ito ay idinisenyo para sa trabaho na maaaring recursively hatiin sa maliit na particle. Ang layunin ay gamitin ang lahat ng magagamit na kapangyarihan sa pag-compute upang mapataas ang pagganap ng iyong aplikasyon. Ang isang makabuluhang bentahe ng framework na ito ay ang paggamit nito ng work-steal algorithm (mula sa trabaho - trabaho at magnakaw - upang magnakaw). Ang mga thread ng manggagawa na naubusan ng trabaho ay maaaring magnakaw ng mga trabaho mula sa iba pang mga thread na abala pa rin.

  25. Ano ang pagkakaiba sa pagitan ng calls to wait() at sleep()?

    26. Bagama't ang parehong paghihintay at pagtulog ay kumakatawan sa isang uri ng pag-pause sa isang Java application, ang mga ito ay mga device para sa iba't ibang pangangailangan. Ang paghihintay ay ginagamit para sa panloob na komunikasyon ng thread, nagbubunga ito upang i-lock kung totoo ang kondisyon ng paghihintay, at naghihintay ng abiso kung ang mga aksyon ng isa pang thread ay ginagawang mali ang kundisyon ng paghihintay. Sa kabilang banda, ang sleep() na pamamaraan ay binibigyan lamang ang processor o pinipigilan ang kasalukuyang thread mula sa pagpapatupad para sa isang tinukoy na tagal ng oras. Ang pagtawag sa sleep() ay hindi naglalabas ng lock na hawak ng kasalukuyang thread.
Mga komento
TO VIEW ALL COMMENTS OR TO MAKE A COMMENT,
GO TO FULL VERSION