{"id":3138,"date":"2022-06-15T05:27:58","date_gmt":"2022-06-15T05:27:58","guid":{"rendered":"http:\/\/the-codest.localhost\/blog\/concurrency-in-java-part-1-introduction\/"},"modified":"2026-03-11T05:59:41","modified_gmt":"2026-03-11T05:59:41","slug":"concurrency-in-java-1-dalis-ivadas","status":"publish","type":"post","link":"https:\/\/thecodest.co\/lt\/blog\/concurrency-in-java-part-1-introduction\/","title":{"rendered":"\"Java\" greitaveika. 1 dalis - \u012fvadas"},"content":{"rendered":"

Apskritai \u012fprastinis programavimo metodas yra nuoseklus. Programoje viskas vyksta po vien\u0105 \u017eingsn\u012f.
Ta\u010diau i\u0161 ties\u0173 lygiagre\u010diai veikia visas pasaulis - tai geb\u0117jimas vienu metu atlikti daugiau nei vien\u0105 u\u017eduot\u012f.<\/p>\n\n\n\n

Sriegis ir procesas<\/h2>\n\n\n\n

Aptarti tokias pa\u017eangias temas kaip lygiagretumas Java<\/a><\/strong> arba daugiajutikl\u012f, turime susitarti d\u0117l bendr\u0173 apibr\u0117\u017e\u010di\u0173, kad b\u016btume tikri, jog sutinkame t\u0105 pat\u012f.<\/p>\n\n\n\n

Prad\u0117kime nuo pagrindini\u0173 dalyk\u0173. Nenuosekliajame pasaulyje turime dviej\u0173 r\u016b\u0161i\u0173 lygiagretumo atstovus: procesus ir
si\u016blai. Procesas yra vykdomos programos egzempliorius. Paprastai jis yra izoliuotas nuo kit\u0173 proces\u0173.
Operacin\u0117 sistema yra atsakinga u\u017e i\u0161tekli\u0173 priskyrim\u0105 kiekvienam procesui. Be to, ji veikia kaip laidininkas, kuris
sudaro tvarkara\u0161\u010dius ir juos kontroliuoja.<\/p>\n\n\n\n

Si\u016blai yra tam tikros r\u016b\u0161ies procesas, ta\u010diau \u017eemesnio lygio, tod\u0117l jie dar vadinami lengvaisiais si\u016blais. Vienoje sistemoje gali veikti kelios gijos
procesas. \u010cia programa veikia kaip tvarkara\u0161\u010dio sudarytojas ir gij\u0173 valdiklis. Taip atskiros programos atrodo atliekan\u010dios
vienu metu atlikti kelias u\u017eduotis.<\/p>\n\n\n\n

Esminis skirtumas tarp gij\u0173 ir proces\u0173 yra izoliacijos lygis. Procesas turi savo rinkin\u012f
i\u0161tekli\u0173, o gija dalijasi duomenys<\/a> su kitomis gijomis. Gali atrodyti, kad tai yra klaidingas metodas, ir i\u0161 ties\u0173 taip yra. D\u0117l
dabar neskirkime tam d\u0117mesio, nes tai i\u0161eina u\u017e \u0161io straipsnio rib\u0173.<\/p>\n\n\n\n

Procesai, gijos - gerai... Bet kas yra lygiagretumas? Sklandumas rei\u0161kia, kad vienu metu galite vykdyti kelias u\u017eduotis.
laikas. Tai nerei\u0161kia, kad tos u\u017eduotys turi b\u016bti atliekamos vienu metu - b\u016btent tai ir yra lygiagretumas. Concurrenc in Javay<\/strong> taip pat neturi
reikia keli\u0173 procesori\u0173 ar net keli\u0173 branduoli\u0173. Tai galima pasiekti vieno branduolio aplinkoje naudojant
konteksto perjungimas.<\/p>\n\n\n\n

Su lygiagretumu susij\u0119s terminas yra daugiaprocesori\u0161kumas. Tai program\u0173 savyb\u0117, leid\u017eianti joms vienu metu vykdyti kelias u\u017eduotis. Ne kiekviena programa taiko \u0161\u012f metod\u0105, ta\u010diau tos, kurios tai daro, gali b\u016bti vadinamos daugiagrandin\u0117mis.<\/p>\n\n\n\n

Esame beveik pasiruo\u0161\u0119, tik dar vienas apibr\u0117\u017eimas. Asinchronizacija rei\u0161kia, kad programa atlieka neblokines operacijas.
Jis inicijuoja u\u017eduot\u012f ir laukdamas atsakymo atlieka kitus veiksmus. Gav\u0119s atsakym\u0105, jis gali reaguoti<\/a> \u012f j\u012f.<\/p>\n\n\n\n

Visas \u0161is d\u017eiazas<\/h2>\n\n\n\n

Pagal numatytuosius nustatymus kiekvienas \"Java\" programa<\/strong> paleid\u017eiamas vienu procesu. Tame procese yra viena gija, susijusi su pagrindinis()<\/code> metodas
parai\u0161k\u0105. Ta\u010diau, kaip min\u0117ta, galima pasinaudoti keli\u0173 gij\u0173 mechanizmais vienoje
programa.<\/p>\n\n\n\n

Vykdomas<\/h3>\n\n\n\n

Sriegis<\/code> yra Java<\/strong> klas\u0117, kurioje \u012fvyksta stebuklas. Tai yra anks\u010diau min\u0117tos gijos objekto atvaizdavimas. \u012e
sukurti savo gij\u0105, galite i\u0161pl\u0117sti Sriegis<\/code> klas\u0117. Ta\u010diau tai nerekomenduojama. Si\u016blai<\/code> tur\u0117t\u0173 b\u016bti naudojamas kaip u\u017eduoties vykdymo mechanizmas. U\u017eduotys yra dalys kodas<\/a> kur\u012f norime paleisti lygiagre\u010diuoju re\u017eimu. Juos galime apibr\u0117\u017eti naudodami Vykdomas<\/code> s\u0105saja.<\/p>\n\n\n\n

Bet u\u017eteks teorijos, d\u0117liokime kod\u0105 ten, kur yra m\u016bs\u0173 burna.<\/p>\n\n\n\n

Problema<\/h3>\n\n\n\n

Tarkime, kad turime kelet\u0105 skai\u010di\u0173 masyv\u0173. Norime su\u017einoti kiekvieno masyvo skai\u010di\u0173 sum\u0105. Tegul
apsimesti, kad toki\u0173 masyv\u0173 yra daug ir kiekvienas i\u0161 j\u0173 yra gana didelis. Esant tokioms s\u0105lygoms, norime pasinaudoti vienalaiki\u0161kumu ir kiekvien\u0105 masyv\u0105 sumuoti kaip atskir\u0105 u\u017eduot\u012f.<\/p>\n\n\n\n

int[] a1 = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};\nint[] a2 = {10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10};\nint[] a3 = {3, 4, 3, 4, 4, 3, 4, 2, 1, 3, 7};\n\nRunnable task1 = () -> {\n    int sum = Arrays.stream(a1).sum();\n    System.out.println(\"1. Suma yra: \" + suma);\n};\n\nRunnable task2 = () -> {\n    int sum = Arrays.stream(a2).sum();\n    System.out.println(\"2. Suma yra: \" + suma);\n};\n\nRunnable task3 = () -> {\n    int sum = Arrays.stream(a3).sum();\n    System.out.println(\"3. Suma yra: \" + suma);\n};\n\nnew Thread(task1).start();\nnew Thread(task2).start();\nnew Thread(task3).start();<\/code><\/pre>\n\n\n\n
Kaip matote i\u0161 pirmiau pateikto kodo Vykdomas<\/code> yra funkcin\u0117 s\u0105saja. Joje yra vienas abstraktus metodas paleisti()<\/code>
be joki\u0173 argument\u0173. Adresas Vykdomas<\/code> s\u0105saja tur\u0117t\u0173 b\u016bti \u012fgyvendinta bet kurioje klas\u0117je, kurios egzemplioriai turi b\u016bti
vykdoma gija.<\/p>\n\n\n\n
Apibr\u0117\u017e\u0119 u\u017eduot\u012f, galite sukurti gij\u0105 jai vykdyti. Tai galima padaryti naudojant nauja gija()<\/code> konstruktorius, kuris
u\u017eima Vykdomas<\/code> kaip argumentas.<\/p>\n\n\n\n
Paskutinis \u017eingsnis - paleisti()<\/code> naujai sukurta gija. \u012e API<\/a> taip pat yra paleisti()<\/code> metodai Vykdomas<\/code> ir
Sriegis<\/code>. Ta\u010diau tai n\u0117ra b\u016bdas i\u0161naudoti \"Java\" lygiagretum\u0105. Tiesioginis kiekvieno i\u0161 \u0161i\u0173 metod\u0173 i\u0161kvietimas sukelia
u\u017eduoties vykdymas tame pa\u010diame sraute. pagrindinis()<\/code> paleid\u017eiamas metodas.<\/p>\n\n\n\n
Sraut\u0173 telkiniai ir vykdytojai<\/h3>\n\n\n\n
Kai u\u017eduo\u010di\u0173 yra daug, kurti atskir\u0105 gij\u0105 kiekvienai u\u017eduo\u010diai n\u0117ra gera id\u0117ja. Sukurti Sriegis<\/code> yra
sunki\u0105 operacij\u0105, tod\u0117l daug geriau pakartotinai naudoti esamas gijas nei kurti naujas.<\/p>\n\n\n\n
Kai programa sukuria daug trumpalaiki\u0173 gij\u0173, geriau naudoti gij\u0173 fond\u0105. Sraut\u0173 fond\u0105 sudaro kelios
paruo\u0161tas paleisti, bet \u0161iuo metu neaktyvias gijas. Suteikiant a Vykdomas<\/code> \u012f fond\u0105, vienas i\u0161 sraut\u0173 i\u0161kvie\u010dia
paleisti()<\/code> pateiktas metodas Vykdomas<\/code>. Atlikus u\u017eduot\u012f, gija vis dar egzistuoja ir yra neveikos b\u016bsenoje.<\/p>\n\n\n\n
Gerai, supratote - pageidaujate si\u016bl\u0173 fondo, o ne rankinio k\u016brimo. Bet kaip galite pasinaudoti si\u016bl\u0173 baseinais? Svetain\u0117 Vykdytojai<\/code>
klas\u0117 turi kelet\u0105 statini\u0173 gamyklini\u0173 metod\u0173, skirt\u0173 si\u016bl\u0173 fondams kurti. Pavyzd\u017eiui newCachedThredPool()<\/code> sukuria
fond\u0105, kuriame naujos gijos kuriamos pagal poreik\u012f, o nenaudojamos gijos saugomos 60 sekund\u017ei\u0173. Prie\u0161ingai,
newFixedThreadPool()<\/code> yra fiksuotas gij\u0173 rinkinys, kuriame neveikian\u010dios gijos laikomos neribot\u0105 laik\u0105.<\/p>\n\n\n\n
Pa\u017ei\u016br\u0117kime, kaip tai gal\u0117t\u0173 veikti m\u016bs\u0173 pavyzdyje. Dabar mums nebereikia kurti gij\u0173 rankiniu b\u016bdu. Vietoj to turime sukurti
ExecutorService<\/code> kuri suteikia gij\u0173 fond\u0105. Tada galime priskirti jam u\u017eduotis. Paskutinis \u017eingsnis - u\u017edaryti gij\u0105
fond\u0105, kad b\u016bt\u0173 i\u0161vengta atminties nutek\u0117jimo. Likusi ankstesnio kodo dalis i\u0161lieka tokia pati.<\/p>\n\n\n\n
ExecutorService executor = Executors.newCachedThreadPool();\n\nexecutor.submit(task1);\nexecutor.submit(task2);\nexecutor.submit(task3);\n\nexecutor.shutdown();<\/code><\/pre>\n\n\n\n
Skambinamas<\/h3>\n\n\n\n
Vykdomas<\/code> atrodo puikus b\u016bdas kurti lygiagre\u010dias u\u017eduotis, ta\u010diau jis turi vien\u0105 didel\u012f tr\u016bkum\u0105. Jis negali gr\u0105\u017einti joki\u0173
vert\u0117. Be to, negalime nustatyti, ar u\u017eduotis baigta, ar ne. Taip pat ne\u017einome, ar ji buvo baigta
paprastai arba i\u0161imties tvarka. \u0160i\u0173 lig\u0173 sprendimas yra Skambinamas<\/code>.<\/p>\n\n\n\n
Skambinamas<\/code> yra pana\u0161us \u012f Vykdomas<\/code> taip pat apima asinchronines u\u017eduotis. Pagrindinis skirtumas yra tas, kad jis gali
gr\u0105\u017einti reik\u0161m\u0119. Gr\u0105\u017einama vert\u0117 gali b\u016bti bet kokio (ne primityvaus) tipo, nes Skambinamas<\/code> s\u0105saja yra parametrizuotas tipas.
Skambinamas<\/code> yra funkcin\u0117 s\u0105saja, turinti skambinti()<\/code> metod\u0105, kuris gali i\u0161mesti I\u0161imtis<\/code>.<\/p>\n\n\n\n
Dabar pa\u017ei\u016br\u0117kime, kaip galime panaudoti Skambinamas<\/code> m\u016bs\u0173 masyvo u\u017edavinyje.<\/p>\n\n\n\n
int[] a1 = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};\nint[] a2 = {10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10};\nint[] a3 = {3, 4, 3, 4, 4, 3, 4, 2, 1, 3, 7};\n\nCallable task1 = () -> Arrays.stream(a1).sum();\nCallable task2 = () -> Arrays.stream(a2).sum();\nCallable task3 = () -> Arrays.stream(a3).sum();\n\nExecutorService executor = Executors.newCachedThreadPool();\nFuture future1 = executor.submit(task1);\nFuture future2 = executor.submit(task2);\nFuture future3 = executor.submit(task3);\n\nSystem.out.println(\"1. Suma yra: \" + future1.get());\nSystem.out.println(\"2. Suma yra: \" + future2.get());\nSystem.out.println(\"3. Suma yra: \" + future3.get());\n\nexecutor.shutdown();<\/code><\/pre>\n\n\n\n
Gerai, matome, kaip Skambinamas<\/code> sukuriamas ir pateikiamas ExecutorService<\/code>. Bet kas, po velni\u0173, yra Ateitis<\/code>?
Ateitis<\/code> veikia kaip tiltas tarp gij\u0173. Kiekvieno masyvo suma sukuriama atskiroje gijoje, tod\u0117l mums reikia b\u016bdo, kaip
gauti \u0161iuos rezultatus atgal \u012f pagrindinis()<\/code>.<\/p>\n\n\n\n
Nor\u0117dami gauti rezultat\u0105 i\u0161 Ateitis<\/code> turime skambinti gauti()<\/code> metodas. \u010cia gali nutikti vienas i\u0161 dviej\u0173 dalyk\u0173. Pirma,
skai\u010diavimo, atlikto Skambinamas<\/code> yra. Tuomet j\u0105 gauname i\u0161 karto. Antra, rezultatas n\u0117ra
dar nepasiruo\u0161\u0119. Tokiu atveju gauti()<\/code> metodas bus u\u017eblokuotas, kol bus gautas rezultatas.<\/p>\n\n\n\n
ComputableFuture<\/h3>\n\n\n\n
Problema su Ateitis<\/code> yra tai, kad jis veikia pagal \"st\u016bmimo paradigm\u0105\". Naudojant Ateitis<\/code> turite b\u016bti kaip bosas, kuris
nuolat klausia: \"Ar tavo u\u017eduotis atlikta? Ar ji paruo\u0161ta?\", kol bus pasiektas rezultatas. Veikti veikiant nuolatiniam spaudimui yra
brangiai kainuoja. Geriau b\u016bt\u0173 u\u017esisakyti Ateitis<\/code> k\u0105 daryti, kai jis bus pasireng\u0119s atlikti u\u017eduot\u012f. Deja,
Ateitis<\/code> negali to padaryti, bet ComputableFuture<\/code> gali.<\/p>\n\n\n\n
ComputableFuture<\/code> veikia pagal \"traukimo paradigm\u0105\". Galime nurodyti, k\u0105 daryti su rezultatu, kai jis atliks savo u\u017eduotis. Jis
yra asinchroninio metodo pavyzdys.<\/p>\n\n\n\n
ComputableFuture<\/code> puikiai veikia su Vykdomas<\/code> bet ne su Skambinamas<\/code>. Vietoj to galima pateikti u\u017eduot\u012f
ComputableFuture<\/code> forma Tiek\u0117jas<\/code>.<\/p>\n\n\n\n
Pa\u017ei\u016br\u0117kime, kaip tai susij\u0119 su m\u016bs\u0173 problema.<\/p>\n\n\n\n
int[] a1 = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};\nint[] a2 = {10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10};\nint[] a3 = {3, 4, 3, 4, 4, 3, 4, 2, 1, 3, 7};\n\nCompletableFuture.supplyAsync(() -> Arrays.stream(a1).sum())\n                .thenAccept(System.out::println);\n\nCompletableFuture.supplyAsync(() -> Arrays.stream(a2).sum())\n                .thenAccept(System.out::println);\n\nCompletableFuture.supplyAsync(() -> Arrays.stream(a3).sum())\n                .thenAccept(System.out::println);<\/code><\/pre>\n\n\n\n
Pirmiausia \u012f akis krenta tai, kad \u0161is sprendimas yra daug trumpesnis. Be to, jis taip pat atrodo \u0161varus ir tvarkingas.<\/p>\n\n\n\n
U\u017eduotis U\u017ebaigiamaB\u016bsimyb\u0117<\/code> gali teikti supplyAsync()<\/code> metod\u0105, kuris priima Tiek\u0117jas<\/code> arba runAsync()<\/code> kad
u\u017eima Vykdomas<\/code>. Gr\u012f\u017etamasis ry\u0161ys - kodo dalis, kuri tur\u0117t\u0173 b\u016bti paleista u\u017ebaigus u\u017eduot\u012f - apibr\u0117\u017eiamas thenAccept()<\/code>
metodas.<\/p>\n\n\n\n
I\u0161vados<\/h2>\n\n\n\n
Java<\/strong> pateikiama daug skirting\u0173 po\u017ei\u016bri\u0173 \u012f lygiagretum\u0105. \u0160iame straipsnyje vos paliet\u0117me \u0161i\u0105 tem\u0105.<\/p>\n\n\n\n
Nepaisant to, ap\u017evelg\u0117me pagrindinius Sriegis<\/code>, Vykdomas<\/code>, Skambinamas<\/code>, ir CallableFuture<\/code> kuris kelia ger\u0105 klausim\u0105
tolesniam temos tyrimui.<\/p>\n\n\n\n
\"\"<\/a><\/figure>","protected":false},"excerpt":{"rendered":"
Perskaitykite pirm\u0105j\u0105 m\u016bs\u0173 tinklara\u0161\u010dio serijos, skirtos \"Java\" lygiagretinimui, dal\u012f. \u0160iame straipsnyje pla\u010diau ap\u017evelgsime skirtumus tarp gij\u0173 ir proces\u0173, gij\u0173 baseinus, vykdytojus ir dar daugiau!<\/p>","protected":false},"author":2,"featured_media":3139,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"_acf_changed":false,"inline_featured_image":false,"footnotes":""},"categories":[8],"tags":[],"class_list":["post-3138","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-software-development"],"acf":[],"yoast_head":"\nConcurrency in Java Part 1 - Introduction - The Codest<\/title>\n<meta name=\"description\" content=\"Read the first part of our blog series devoted to concurrency in Java.\" \/>\n<meta name=\"robots\" content=\"index, follow, max-snippet:-1, max-image-preview:large, max-video-preview:-1\" \/>\n<link rel=\"canonical\" href=\"https:\/\/thecodest.co\/lt\/tinklarastis\/concurrency-in-java-1-dalis-ivadas\/\" \/>\n<meta property=\"og:locale\" content=\"lt_LT\" \/>\n<meta property=\"og:type\" content=\"article\" \/>\n<meta property=\"og:title\" content=\"Concurrency in Java Part 1 - Introduction\" \/>\n<meta property=\"og:description\" content=\"Read the first part of our blog series devoted to concurrency in Java.\" \/>\n<meta property=\"og:url\" content=\"https:\/\/thecodest.co\/lt\/tinklarastis\/concurrency-in-java-1-dalis-ivadas\/\" \/>\n<meta property=\"og:site_name\" content=\"The Codest\" \/>\n<meta property=\"article:published_time\" content=\"2022-06-15T05:27:58+00:00\" \/>\n<meta property=\"article:modified_time\" content=\"2026-03-11T05:59:41+00:00\" \/>\n<meta property=\"og:image\" content=\"https:\/\/thecodest.co\/app\/uploads\/2024\/05\/concurrency_in_java_part_1_-_introduction.png\" \/>\n\t<meta property=\"og:image:width\" content=\"960\" \/>\n\t<meta property=\"og:image:height\" content=\"540\" \/>\n\t<meta property=\"og:image:type\" content=\"image\/png\" \/>\n<meta name=\"author\" content=\"thecodest\" \/>\n<meta name=\"twitter:card\" content=\"summary_large_image\" \/>\n<meta name=\"twitter:label1\" content=\"Written by\" \/>\n\t<meta name=\"twitter:data1\" content=\"thecodest\" \/>\n\t<meta name=\"twitter:label2\" content=\"Est. reading time\" \/>\n\t<meta name=\"twitter:data2\" content=\"6 minutes\" \/>\n<script type=\"application\/ld+json\" class=\"yoast-schema-graph\">{\"@context\":\"https:\\\/\\\/schema.org\",\"@graph\":[{\"@type\":\"Article\",\"@id\":\"https:\\\/\\\/thecodest.co\\\/blog\\\/concurrency-in-java-part-1-introduction\\\/#article\",\"isPartOf\":{\"@id\":\"https:\\\/\\\/thecodest.co\\\/blog\\\/concurrency-in-java-part-1-introduction\\\/\"},\"author\":{\"name\":\"thecodest\",\"@id\":\"https:\\\/\\\/thecodest.co\\\/#\\\/schema\\\/person\\\/7e3fe41dfa4f4e41a7baad4c6e0d4f76\"},\"headline\":\"Concurrency in Java Part 1 – Introduction\",\"datePublished\":\"2022-06-15T05:27:58+00:00\",\"dateModified\":\"2026-03-11T05:59:41+00:00\",\"mainEntityOfPage\":{\"@id\":\"https:\\\/\\\/thecodest.co\\\/blog\\\/concurrency-in-java-part-1-introduction\\\/\"},\"wordCount\":1295,\"commentCount\":0,\"publisher\":{\"@id\":\"https:\\\/\\\/thecodest.co\\\/#organization\"},\"image\":{\"@id\":\"https:\\\/\\\/thecodest.co\\\/blog\\\/concurrency-in-java-part-1-introduction\\\/#primaryimage\"},\"thumbnailUrl\":\"https:\\\/\\\/thecodest.co\\\/app\\\/uploads\\\/2024\\\/05\\\/concurrency_in_java_part_1_-_introduction.png\",\"articleSection\":[\"Software Development\"],\"inLanguage\":\"lt-LT\",\"potentialAction\":[{\"@type\":\"CommentAction\",\"name\":\"Comment\",\"target\":[\"https:\\\/\\\/thecodest.co\\\/blog\\\/concurrency-in-java-part-1-introduction\\\/#respond\"]}]},{\"@type\":\"WebPage\",\"@id\":\"https:\\\/\\\/thecodest.co\\\/blog\\\/concurrency-in-java-part-1-introduction\\\/\",\"url\":\"https:\\\/\\\/thecodest.co\\\/blog\\\/concurrency-in-java-part-1-introduction\\\/\",\"name\":\"Concurrency in Java Part 1 - Introduction - The Codest\",\"isPartOf\":{\"@id\":\"https:\\\/\\\/thecodest.co\\\/#website\"},\"primaryImageOfPage\":{\"@id\":\"https:\\\/\\\/thecodest.co\\\/blog\\\/concurrency-in-java-part-1-introduction\\\/#primaryimage\"},\"image\":{\"@id\":\"https:\\\/\\\/thecodest.co\\\/blog\\\/concurrency-in-java-part-1-introduction\\\/#primaryimage\"},\"thumbnailUrl\":\"https:\\\/\\\/thecodest.co\\\/app\\\/uploads\\\/2024\\\/05\\\/concurrency_in_java_part_1_-_introduction.png\",\"datePublished\":\"2022-06-15T05:27:58+00:00\",\"dateModified\":\"2026-03-11T05:59:41+00:00\",\"description\":\"Read the first part of our blog series devoted to concurrency in Java.\",\"breadcrumb\":{\"@id\":\"https:\\\/\\\/thecodest.co\\\/blog\\\/concurrency-in-java-part-1-introduction\\\/#breadcrumb\"},\"inLanguage\":\"lt-LT\",\"potentialAction\":[{\"@type\":\"ReadAction\",\"target\":[\"https:\\\/\\\/thecodest.co\\\/blog\\\/concurrency-in-java-part-1-introduction\\\/\"]}]},{\"@type\":\"ImageObject\",\"inLanguage\":\"lt-LT\",\"@id\":\"https:\\\/\\\/thecodest.co\\\/blog\\\/concurrency-in-java-part-1-introduction\\\/#primaryimage\",\"url\":\"https:\\\/\\\/thecodest.co\\\/app\\\/uploads\\\/2024\\\/05\\\/concurrency_in_java_part_1_-_introduction.png\",\"contentUrl\":\"https:\\\/\\\/thecodest.co\\\/app\\\/uploads\\\/2024\\\/05\\\/concurrency_in_java_part_1_-_introduction.png\",\"width\":960,\"height\":540},{\"@type\":\"BreadcrumbList\",\"@id\":\"https:\\\/\\\/thecodest.co\\\/blog\\\/concurrency-in-java-part-1-introduction\\\/#breadcrumb\",\"itemListElement\":[{\"@type\":\"ListItem\",\"position\":1,\"name\":\"Home\",\"item\":\"https:\\\/\\\/thecodest.co\\\/\"},{\"@type\":\"ListItem\",\"position\":2,\"name\":\"Concurrency in Java Part 1 – Introduction\"}]},{\"@type\":\"WebSite\",\"@id\":\"https:\\\/\\\/thecodest.co\\\/#website\",\"url\":\"https:\\\/\\\/thecodest.co\\\/\",\"name\":\"The Codest\",\"description\":\"\",\"publisher\":{\"@id\":\"https:\\\/\\\/thecodest.co\\\/#organization\"},\"potentialAction\":[{\"@type\":\"SearchAction\",\"target\":{\"@type\":\"EntryPoint\",\"urlTemplate\":\"https:\\\/\\\/thecodest.co\\\/?s={search_term_string}\"},\"query-input\":{\"@type\":\"PropertyValueSpecification\",\"valueRequired\":true,\"valueName\":\"search_term_string\"}}],\"inLanguage\":\"lt-LT\"},{\"@type\":\"Organization\",\"@id\":\"https:\\\/\\\/thecodest.co\\\/#organization\",\"name\":\"The Codest\",\"url\":\"https:\\\/\\\/thecodest.co\\\/\",\"logo\":{\"@type\":\"ImageObject\",\"inLanguage\":\"lt-LT\",\"@id\":\"https:\\\/\\\/thecodest.co\\\/#\\\/schema\\\/logo\\\/image\\\/\",\"url\":\"https:\\\/\\\/thecodest.co\\\/app\\\/uploads\\\/2024\\\/03\\\/thecodest-logo.svg\",\"contentUrl\":\"https:\\\/\\\/thecodest.co\\\/app\\\/uploads\\\/2024\\\/03\\\/thecodest-logo.svg\",\"width\":144,\"height\":36,\"caption\":\"The Codest\"},\"image\":{\"@id\":\"https:\\\/\\\/thecodest.co\\\/#\\\/schema\\\/logo\\\/image\\\/\"},\"sameAs\":[\"https:\\\/\\\/pl.linkedin.com\\\/company\\\/codest\",\"https:\\\/\\\/clutch.co\\\/profile\\\/codest\"]},{\"@type\":\"Person\",\"@id\":\"https:\\\/\\\/thecodest.co\\\/#\\\/schema\\\/person\\\/7e3fe41dfa4f4e41a7baad4c6e0d4f76\",\"name\":\"thecodest\",\"image\":{\"@type\":\"ImageObject\",\"inLanguage\":\"lt-LT\",\"@id\":\"https:\\\/\\\/secure.gravatar.com\\\/avatar\\\/5dbfe6a1e8c86e432e8812759e34e6fe82ebac75119ae3237a6c1311fa19caf4?s=96&d=mm&r=g\",\"url\":\"https:\\\/\\\/secure.gravatar.com\\\/avatar\\\/5dbfe6a1e8c86e432e8812759e34e6fe82ebac75119ae3237a6c1311fa19caf4?s=96&d=mm&r=g\",\"contentUrl\":\"https:\\\/\\\/secure.gravatar.com\\\/avatar\\\/5dbfe6a1e8c86e432e8812759e34e6fe82ebac75119ae3237a6c1311fa19caf4?s=96&d=mm&r=g\",\"caption\":\"thecodest\"},\"url\":\"https:\\\/\\\/thecodest.co\\\/lt\\\/author\\\/thecodest\\\/\"}]}<\/script>\n<!-- \/ Yoast SEO Premium plugin. -->","yoast_head_json":{"title":"\"Java\" greitaveika. 1 dalis - \u012evadas - The Codest","description":"Perskaitykite pirm\u0105j\u0105 m\u016bs\u0173 tinklara\u0161\u010dio serijos, skirtos \"Java\" lygiagretinimui, dal\u012f.","robots":{"index":"index","follow":"follow","max-snippet":"max-snippet:-1","max-image-preview":"max-image-preview:large","max-video-preview":"max-video-preview:-1"},"canonical":"https:\/\/thecodest.co\/lt\/tinklarastis\/concurrency-in-java-1-dalis-ivadas\/","og_locale":"lt_LT","og_type":"article","og_title":"Concurrency in Java Part 1 - Introduction","og_description":"Read the first part of our blog series devoted to concurrency in Java.","og_url":"https:\/\/thecodest.co\/lt\/tinklarastis\/concurrency-in-java-1-dalis-ivadas\/","og_site_name":"The Codest","article_published_time":"2022-06-15T05:27:58+00:00","article_modified_time":"2026-03-11T05:59:41+00:00","og_image":[{"width":960,"height":540,"url":"https:\/\/thecodest.co\/app\/uploads\/2024\/05\/concurrency_in_java_part_1_-_introduction.png","type":"image\/png"}],"author":"thecodest","twitter_card":"summary_large_image","twitter_misc":{"Written by":"thecodest","Est. reading time":"6 minutes"},"schema":{"@context":"https:\/\/schema.org","@graph":[{"@type":"Article","@id":"https:\/\/thecodest.co\/blog\/concurrency-in-java-part-1-introduction\/#article","isPartOf":{"@id":"https:\/\/thecodest.co\/blog\/concurrency-in-java-part-1-introduction\/"},"author":{"name":"thecodest","@id":"https:\/\/thecodest.co\/#\/schema\/person\/7e3fe41dfa4f4e41a7baad4c6e0d4f76"},"headline":"Concurrency in Java Part 1 – Introduction","datePublished":"2022-06-15T05:27:58+00:00","dateModified":"2026-03-11T05:59:41+00:00","mainEntityOfPage":{"@id":"https:\/\/thecodest.co\/blog\/concurrency-in-java-part-1-introduction\/"},"wordCount":1295,"commentCount":0,"publisher":{"@id":"https:\/\/thecodest.co\/#organization"},"image":{"@id":"https:\/\/thecodest.co\/blog\/concurrency-in-java-part-1-introduction\/#primaryimage"},"thumbnailUrl":"https:\/\/thecodest.co\/app\/uploads\/2024\/05\/concurrency_in_java_part_1_-_introduction.png","articleSection":["Software Development"],"inLanguage":"lt-LT","potentialAction":[{"@type":"CommentAction","name":"Comment","target":["https:\/\/thecodest.co\/blog\/concurrency-in-java-part-1-introduction\/#respond"]}]},{"@type":"WebPage","@id":"https:\/\/thecodest.co\/blog\/concurrency-in-java-part-1-introduction\/","url":"https:\/\/thecodest.co\/blog\/concurrency-in-java-part-1-introduction\/","name":"\"Java\" greitaveika. 1 dalis - \u012evadas - The Codest","isPartOf":{"@id":"https:\/\/thecodest.co\/#website"},"primaryImageOfPage":{"@id":"https:\/\/thecodest.co\/blog\/concurrency-in-java-part-1-introduction\/#primaryimage"},"image":{"@id":"https:\/\/thecodest.co\/blog\/concurrency-in-java-part-1-introduction\/#primaryimage"},"thumbnailUrl":"https:\/\/thecodest.co\/app\/uploads\/2024\/05\/concurrency_in_java_part_1_-_introduction.png","datePublished":"2022-06-15T05:27:58+00:00","dateModified":"2026-03-11T05:59:41+00:00","description":"Perskaitykite pirm\u0105j\u0105 m\u016bs\u0173 tinklara\u0161\u010dio serijos, skirtos \"Java\" lygiagretinimui, dal\u012f.","breadcrumb":{"@id":"https:\/\/thecodest.co\/blog\/concurrency-in-java-part-1-introduction\/#breadcrumb"},"inLanguage":"lt-LT","potentialAction":[{"@type":"ReadAction","target":["https:\/\/thecodest.co\/blog\/concurrency-in-java-part-1-introduction\/"]}]},{"@type":"ImageObject","inLanguage":"lt-LT","@id":"https:\/\/thecodest.co\/blog\/concurrency-in-java-part-1-introduction\/#primaryimage","url":"https:\/\/thecodest.co\/app\/uploads\/2024\/05\/concurrency_in_java_part_1_-_introduction.png","contentUrl":"https:\/\/thecodest.co\/app\/uploads\/2024\/05\/concurrency_in_java_part_1_-_introduction.png","width":960,"height":540},{"@type":"BreadcrumbList","@id":"https:\/\/thecodest.co\/blog\/concurrency-in-java-part-1-introduction\/#breadcrumb","itemListElement":[{"@type":"ListItem","position":1,"name":"Home","item":"https:\/\/thecodest.co\/"},{"@type":"ListItem","position":2,"name":"Concurrency in Java Part 1 – Introduction"}]},{"@type":"WebSite","@id":"https:\/\/thecodest.co\/#website","url":"https:\/\/thecodest.co\/","name":"The Codest","description":"","publisher":{"@id":"https:\/\/thecodest.co\/#organization"},"potentialAction":[{"@type":"SearchAction","target":{"@type":"EntryPoint","urlTemplate":"https:\/\/thecodest.co\/?s={search_term_string}"},"query-input":{"@type":"PropertyValueSpecification","valueRequired":true,"valueName":"search_term_string"}}],"inLanguage":"lt-LT"},{"@type":"Organization","@id":"https:\/\/thecodest.co\/#organization","name":"The Codest","url":"https:\/\/thecodest.co\/","logo":{"@type":"ImageObject","inLanguage":"lt-LT","@id":"https:\/\/thecodest.co\/#\/schema\/logo\/image\/","url":"https:\/\/thecodest.co\/app\/uploads\/2024\/03\/thecodest-logo.svg","contentUrl":"https:\/\/thecodest.co\/app\/uploads\/2024\/03\/thecodest-logo.svg","width":144,"height":36,"caption":"The Codest"},"image":{"@id":"https:\/\/thecodest.co\/#\/schema\/logo\/image\/"},"sameAs":["https:\/\/pl.linkedin.com\/company\/codest","https:\/\/clutch.co\/profile\/codest"]},{"@type":"Person","@id":"https:\/\/thecodest.co\/#\/schema\/person\/7e3fe41dfa4f4e41a7baad4c6e0d4f76","name":"thecodest","image":{"@type":"ImageObject","inLanguage":"lt-LT","@id":"https:\/\/secure.gravatar.com\/avatar\/5dbfe6a1e8c86e432e8812759e34e6fe82ebac75119ae3237a6c1311fa19caf4?s=96&d=mm&r=g","url":"https:\/\/secure.gravatar.com\/avatar\/5dbfe6a1e8c86e432e8812759e34e6fe82ebac75119ae3237a6c1311fa19caf4?s=96&d=mm&r=g","contentUrl":"https:\/\/secure.gravatar.com\/avatar\/5dbfe6a1e8c86e432e8812759e34e6fe82ebac75119ae3237a6c1311fa19caf4?s=96&d=mm&r=g","caption":"thecodest"},"url":"https:\/\/thecodest.co\/lt\/author\/thecodest\/"}]}},"_links":{"self":[{"href":"https:\/\/thecodest.co\/lt\/wp-json\/wp\/v2\/posts\/3138","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/thecodest.co\/lt\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/thecodest.co\/lt\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/thecodest.co\/lt\/wp-json\/wp\/v2\/users\/2"}],"replies":[{"embeddable":true,"href":"https:\/\/thecodest.co\/lt\/wp-json\/wp\/v2\/comments?post=3138"}],"version-history":[{"count":8,"href":"https:\/\/thecodest.co\/lt\/wp-json\/wp\/v2\/posts\/3138\/revisions"}],"predecessor-version":[{"id":8551,"href":"https:\/\/thecodest.co\/lt\/wp-json\/wp\/v2\/posts\/3138\/revisions\/8551"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/thecodest.co\/lt\/wp-json\/wp\/v2\/media\/3139"}],"wp:attachment":[{"href":"https:\/\/thecodest.co\/lt\/wp-json\/wp\/v2\/media?parent=3138"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/thecodest.co\/lt\/wp-json\/wp\/v2\/categories?post=3138"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/thecodest.co\/lt\/wp-json\/wp\/v2\/tags?post=3138"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}