Գնահատել նախագիծը
← Բոլոր հրապարակումները

Ի՞նչ է նշանակում blocking Loom-ում

Project Loom-ը Java runtime է բերում Virtual Threads-ը, որոնք կմտնեն JDK 21-ի մեջ։ Արդյունավետության իր նպատակներին հասնելու համար Loom-ի runtime-ը հոգ է տանում blocking գործողությունների մասին։

15 րոպե
JavaProject LoomConcurrencyJVMMultithreadingvirtual threads

Project Loom-ը Java runtime է բերում Virtual Threads-ի գաղափարը, և սեպտեմբերին այն կհայտնվի որպես կայուն հնարավորություն JDK 21-ում։ Project Loom-ի նպատակն է համատեղել ասինխրոն ծրագրավորման արդյունավետության առավելությունները կոդ գրելու ուղիղ, «սինխրոն» ոճի պարզության հետ։

Այդ նպատակներին հասնելու համար Loom-ի runtime-ը պետք է յուրաքանչյուր blocking գործողության հետ վարվի առանձնահատուկ ձևով։ Տեսնենք, թե ինչպես է աշխատում այդ առանձնահատուկ մոտեցումը և արդյոք Loom-ով ծրագրավորումը ունի որևէ անկյունային դեպք։

Նախքան սկսելը արժե պարզաբանել, թե ինչ է այստեղ նշանակում blocking. դա ծրագրի thread-ի վիճակ է, երբ thread-ը ոչ մի օգտակար աշխատանք չի կատարում (չի օգտագործում CPU-ն) և փոխարենը սպասում է, որ ինչ-որ արտաքին պայման կատարվի։ Տիպային օրինակներն են սեմաֆորի վրա սպասելը կամ socket-ում տվյալների ժամանումին սպասելը։

Carrier և virtual thread-եր

Սկսենք Loom-ի հիմնական հասկացությունների կարճ ակնարկից։ Հիմքում platform thread-երն են, որոնք կոչվում են նաև kernel thread-եր։ Java-ն այդ thread-երն ունեցել է վաղուց. մինչ այժմ աշխատող յուրաքանչյուր Thread օրինակ համապատասխանում էր ճիշտ մեկ kernel thread-ի։ Նման thread-երը ծանր են, և՛ դրանք ստեղծելը, և՛ դրանց միջև փոխարկվելը թանկ է։ Դրանք սահմանափակ ռեսուրս են, որը պետք է կառավարել զգուշորեն, օրինակ՝ thread pool-ի միջոցով։

Virtual thread-երը Loom-ի բերած նոր հասկացություն են։ Դրանք թեթև են և էժան ստեղծվում են՝ թե՛ հիշողության տեսանկյունից, թե՛ context-ների փոխարկման ժամանակի առումով։ Այն JDK-ում, որտեղ virtual thread-երը միացված են, Thread օրինակը կարող է նշանակել և՛ platform thread, և՛ virtual thread։ API-ն մնում է նույնը, բայց յուրաքանչյուր տեսակի աշխատեցման արժեքը զգալիորեն տարբերվում է։

Ներքուստ JVM+Loom runtime-ը պահում է platform thread-երի pool, որոնք հայտնի են որպես carrier thread-եր, և որոնց վրա multiplex են արվում virtual thread-երը։ Այլ կերպ ասած՝ մի քանի platform thread կատարում են մեծ թվով virtual thread-եր։ Ամեն անգամ, երբ virtual thread-ը կանչում է blocking գործողություն, այն պետք է «մի կողմ դրվի», մինչև այն պայմանը, որին սպասում է, կատարվի, որպեսզի մեկ այլ virtual thread կարողանա աշխատել հենց նոր ազատված carrier thread-ի վրա։

Այս գաղափարը նոր չէ. տարբեր reactive գրադարաններ այն իրականացրել են thread pool-երով և non-blocking I/O-ով։ Սակայն այստեղ դա տեղի է ունենում runtime-ի մակարդակում, այլ ոչ թե գրադարանում, ինչը մեզ տալիս է շատ ավելի մաքուր շարահյուսություն և իմաստալից stack trace-եր և խնայում է մեզ Future wrapper-ի նման բաների «վիրուսայնությունից»։

Loom-ի ներածության մեջ մենք այսքանով կսահմանափակվենք. ավելի մանրակրկիտ ուսումնասիրության համար խորհուրդ եմ տալիս Rock the JVM բլոգի The Ultimate guide to Virtual Threads հոդվածը։

Հիմնական կետն այն է, որ համակարգը կայուն առաջընթաց ապահովի (երբ օգտագործվում են շատ virtual thread-եր), carrier thread-երը պետք է բավական հաճախ ազատվեն, որպեսզի virtual thread-երը կարողանան նրանց վրա պլանավորվել։ Ահա թե ինչու I/O-ով ծանրաբեռնված համակարգերը պետք է ամենից շատ շահեն, մինչդեռ CPU-ով ծանրաբեռնված հավելվածները Loom-ի ընդունումից քիչ բան կշահեն։

Այս ամենը ենթադրում է, որ յուրաքանչյուր blocking գործողություն ազատում է carrier thread-ը, որպեսզի նրա տեղը կարողանա գրավել մեկ այլ virtual thread։ Բայց իսկապե՞ս այդպես է։

Blocking-ի հարմարեցում (retrofitting)

Ինչպես նշվեց, virtual thread-երի իրականացումը մեծ մասամբ նշանակում էր, որ Project Loom-ը պետք է հարմարեցներ գոյություն ունեցող blocking գործողությունները՝ դրանք virtual thread-երին «տեղյակ» դարձնելու համար։ Արդյունքում, երբ նման գործողություններ են կանչվում, դրանք ազատում են carrier thread-ը՝ թույլ տալով այլ virtual thread-երին շարունակել։

Օրինակ, երբ կոդը արգելափակվում է սեմաֆորի, lock-ի կամ Java-ի concurrency-ի որևէ այլ պրիմիտիվի վրա, հիմքում ընկած carrier thread-ը չի արգելափակվում։ Փոխարենը runtime-ին ազդանշան է տրվում՝ գրավել ընթացիկ virtual thread-ի continuation-ը, դնել այն սպասման հերթում և վերսկսել այն, հենց որ արգելափակման պատճառ դարձած պայմանը լուծվի։

Նույն կերպ Thread.sleep-ը այժմ արգելափակում է միայն virtual thread-ը և carrier thread-ը թողնում է ազատ։ Հետևաբար հետևյալ կոդն ավարտվում է 4 վայրկյանում՝ չնայած որ գործարկվում է ընդամենը մոտ 15 platform thread (virtual thread-եր աշխատեցնող carrier thread pool-ի չափը կախված է նրանից, թե քանի միջուկ է հասանելի JVM-ին).

var e = Executors.newVirtualThreadPerTaskExecutor();
for (int i = 0; i < 1000; i++) {
    e.submit(() -> { sleep(4000); });
}
e.shutdown();
e.awaitTermination(1, TimeUnit.DAYS);

Սինքրոնիզացիայի խնդիրներ

Սակայն Java-ի ոչ բոլոր կառուցվածքներն են այսպես հարմարեցվել։ Նրանց թվում, որոնք չեն հարմարեցվել, synchronized մեթոդներն ու կոդի բլոկներն են։ Երբ դրանք օգտագործվում են, virtual thread-ը ամրացվում է (pinned) իր carrier thread-ին։ Մինչ thread-ը ամրացված է, ցանկացած blocking գործողություն արգելափակում է հիմքում ընկած carrier thread-ը՝ ճիշտ այնպես, ինչպես մինչև Loom-ը։

Դիտարկենք այս օրինակը.

var e = Executors.newVirtualThreadPerTaskExecutor();
for (int i = 0; i < 1000; i++) {
    e.submit(() -> { new Test().test(); });
}
e.shutdown();
e.awaitTermination(1, TimeUnit.DAYS);

class Test {
    synchronized void test() {
        sleep(4000);
    }
}

Նկատեք, որ ներկայացված յուրաքանչյուր առաջադրանք ստեղծում է նոր Test, ուստի synchronized void test() մեթոդի յուրաքանչյուր կանչի համար օգտագործվում է տարբեր monitor։ Այդուհանդերձ, քանի որ մենք հենվում ենք synchronized-ի վրա, thread-ն ամրացվում է carrier thread-ին։ Carrier pool-ում 5 thread-ի դեպքում միաժամանակ կարող են աշխատել ընդամենը հինգ առաջադրանք (քանի որ դրանք արգելափակում են ամբողջ pool-ը)։ Արդյունքում, թեև այս կոդը նախորդ օրինակից տարբերվում է միայն թեթևակի, այն ավարտվելու համար պահանջում է 1000/5*4 = 800 վայրկյան։

Լուծումը synchronized հիմնաբառը lock-երով փոխարինելն է.

var e = Executors.newVirtualThreadPerTaskExecutor();
for (int i = 0; i < 1000; i++) {
    e.submit(() -> { new Test().test(); });
}
e.shutdown();
e.awaitTermination(1, TimeUnit.DAYS);

class Test {
    private ReentrantLock lock = new ReentrantLock();
    void test() {
        lock.tryLock();
        try {
            sleep(4000);
        } finally {
            lock.unlock();
        }
    }
}

Loom-ի դեպքում սա նորից ավարտվում է 4 վայրկյանում։

synchronized բլոկները lock-երով փոխարինելը JDK-ի ներսում (որտեղ հնարավոր է) Project Loom-ի շրջանակի և JDK 21-ում առաքվող բաների մեկ այլ մասն է։ Java-ի և JVM-ի տարբեր գրադարաններ արդեն արել են կամ այժմ անում են նույնատիպ փոփոխություններ (օրինակ՝ JDBC դրայվերները)։ Սակայն synchronized-ի վրա հենվող հավելվածի կոդը կպահանջի լրացուցիչ ուշադրություն։

Socket-ներ

Կա՞ն արդյոք այլ ոլորտներ, ինչպես synchronized-ը, որոնք հանգեցնում են thread-երի ամրացման և հետևաբար կարող են վնասել մեր հավելվածի արդյունավետությանը։

Բարեբախտաբար, I/O-ի ամենատարածված աղբյուրներից մեկը՝ TCP socket-ներով ցանցային հաղորդակցությունը, լիովին «տեղյակ» է Loom-ին։ Դա զարմանալի չէ. socket-ները կարելի է մշակել non-blocking եղանակով (կա՛մ լիովին non-blocking, կա՛մ մեկ «կառավարիչ» thread-ով, որը համակարգում է բազմաթիվ I/O առաջադրանքների կատարումը) select() կամ epoll() նման մեխանիզմների միջոցով։

Հենց սրա վրա է Project Loom-ը ներքուստ հենվում՝ առաջարկելու socket-ի իրականացում, որը լավ համագործակցում է virtual thread-երի հետ։ Non-blocking I/O-ի մանրամասները մնում են թաքնված, և մենք աշխատում ենք ծանոթ, սինխրոն API-ով։ Լրիվ օրինակը, որն ուղղակիորեն օգտագործում է java.net.Socket, բավական երկար կլիներ, ուստի պատկերացրեք մեկը, որը միաժամանակ մի քանի հարցում է ուղարկում սերվերին, որն արձագանքում է 3 վայրկյան անց։

Ավելի մոտիկից նայելիս կնկատեք InputStream.read կանչերը, փաթաթված BufferedReader-ի մեջ, որը կարդում է socket-ի մուտքից։ Սա այն blocking կանչն է, որը կասեցնում է virtual thread-ը։ Loom-ի դեպքում թեստն ավարտվում է 3 վայրկյանում, թեև ողջ JVM-ում երբևէ գործարկվում է ընդամենը 16 platform thread, և 50 հարցում աշխատում է միաժամանակ։

Սակայն պատկերը փոխվում է datagram socket-ների (որոնք օգտագործում են UDP պրոտոկոլը) դեպքում։ Կրկին ունենք սերվեր, որը 3 վայրկյան անց պատասխանում է UDP փաթեթով, բայց երբ գործարկեք կլիենտը, կգտնեք, որ DatagramSocket.receive-ը ամրացնում է thread-ը, ուստի ցանկացած պահի միայն մի քանի կլիենտ (առավելագույնը carrier thread pool-ի չափով) կարող են առաջ շարժվել։ Հետևաբար ամբողջ թեստը տևում է ավելի երկար։

Մինչ այժմ մենք բացահայտել ենք thread-երի ամրացման առնվազն երկու պատճառ՝ synchronized բլոկները և datagram socket-ները։ Կա՞ն այլ պատճառներ։

Ֆայլեր և DNS

Կան. այլ API-ներ ևս ամրացնում են thread-երը և արգելափակում carrier thread-ը, այն է՝ ֆայլերի հետ յուրաքանչյուր գործողություն (FileInputStream-ից կարդալը, ֆայլ գրելը, դիրեկտորիաների ցուցակագրումը և այլն), ինչպես նաև դոմենային անունները IP հասցեների վերածելը InetSocketAddress-ով։

Սա կարող է տագնապալի թվալ, բայց Loom-ը որոշ հակամիջոցներ կիրառում է։ Եթե նայեք FileInputStream-ի, InetSocketAddress-ի կամ DatagramSocket-ի սկզբնական կոդին, կնկատեք jdk.internal.misc.Blocker դասի օգտագործումը։ Նրա begin()/end() մեթոդների կանչերը փաթաթում են carrier thread-ը արգելափակող յուրաքանչյուր կանչ։

Նրա JavaDoc-ը բացատրում է, թե ինչի համար է այն.

/**
 * Defines static methods to mark the beginning and end of a possibly blocking
 * operation. The methods are intended to be used with try-finally as follows:
 * {@snippet lang=java :
 *  long comp = Blocker.begin();
 *  try {
 *    // blocking operation
 *  } finally {
 *    Blocker.end(comp);
 *  }
 * }
 * If invoked from a virtual thread and the underlying carrier thread is a
 * CarrierThread then the code in the block runs as if it were in run in
 * ForkJoinPool.ManagedBlocker. This means the pool can be expanded to support
 * additional parallelism during the blocking operation.
 */
public class Blocker

Այլ կերպ ասած՝ երբ տեղի է ունենում blocking գործողություն, carrier thread pool-ը կարող է ընդլայնվել՝ փոխհատուցելու thread-ի ամրացման հետևանքը։ Կարող է գործարկվել նոր carrier thread, որը կարող է աշխատեցնել virtual thread-եր։

Կողմնակի նշում. ստուգելը, թե որտեղ է օգտագործվում Blocker դասը, նաև հարմար եղանակ է պարզելու, թե տվյալ JDK տարբերակում որ API-ներն են ամրացնում thread-երը։

Ամրացված thread-երի հայտնաբերումը և carrier pool-ի կոնֆիգուրացիան

Եթե thread-երի ամրացումը ձեզ անհանգստացնում է, դուք լավ ընկերակցության մեջ եք. դա անշուշտ մի բան է, որին պետք է հետևել։ Բարեբախտաբար, JVM-ը կարող է հաղորդել դրա յուրաքանչյուր դեպքի մասին, եթե փոխանցեք -Djdk.tracePinnedThreads=short դրոշը (կա նաև full տարբերակ, որը տպում է ամբողջական stack trace-ը)։

Սա արտադրում է հետևյալի նման հաղորդագրություններ.

Thread[#91,ForkJoinPool-1-worker-7,5,CarrierThreads]
    java.base/sun.nio.ch.DatagramSocketAdaptor.receive(DatagramSocketAdaptor.java:241) <== monitors:1

Բացի այդ, carrier thread pool-ի սկզբնական և առավելագույն չափը կարելի է կարգավորել jdk.virtualThreadScheduler.parallelism, jdk.virtualThreadScheduler.maxPoolSize և jdk.virtualThreadScheduler.minRunnable կոնֆիգուրացիայի տարբերակներով։ Դրանք ուղղակիորեն համապատասխանում են ForkJoinPool-ի կոնստրուկտորի արգումենտներին։

Սա չի կանխի thread-երի ամրացումը, բայց թույլ է տալիս հայտնաբերել, թե երբ է այն տեղի ունենում, և անհրաժեշտության դեպքում վերաշարադրել խնդրահարույց կոդի ուղիները։

Արդյո՞ք դատապարտված ենք blocking-ի

Որոշ չափով՝ այո. որոշ գործողություններ իրենց էությամբ blocking են մեր օպերացիոն համակարգերի կառուցվածքի պատճառով։

Վերցնենք page fault-երը. եթե մեր հավելվածը դիմում է հիշողության, որը swap է արվել սկավառակ, տեղի է ունենում page fault։ Օպերացիոն համակարգը պետք է հիշողության պարունակությունը բեռնի սկավառակից, մինչ մեր հավելվածը կարողանա շարունակել։ Այդ բեռնման ընթացքում էջին դիմած thread-ը արգելափակված է։ Ո՛չ JVM-ը, ո՛չ որևէ այլ runtime այստեղ խոսք չունեն։ Նման ցածր մակարդակի հիշողության կառավարումը լիովին kernel-ի գործն է և ամբողջովին անտեսանելի է հավելվածի համար։ Այսպիսով՝ մենք երբեք չենք կարող լիովին վերացնել blocking-ը, թեկուզ այն դրսևորվի միայն page fault-երի տեսքով։

Հաջորդը՝ իսկ ի՞նչ ֆայլերի հետ։ Kernel-ի տեսանկյունից socket-ից կարդալը կարող է արգելափակվել, քանի որ socket-ը կարող է դեռ տվյալներ չունենալ (կարող է «պատրաստ» չլինել)։ Socket-ից կարդալը կարող է նշանակել ցանցով տվյալների ժամանումին սպասել։ Ֆայլերի դեպքը այլ է, քանի որ դրանք կարդացվում են տեղական block սարքերից։ Տվյալները միշտ այնտեղ են. առավելագույնը դրանք պետք է պատճենվեն սկավառակից հիշողություն։

Ինչ-որ իմաստով, ինչ վերաբերում է kernel-ին, ֆայլային գործողությունները երբեք չեն արգելափակվում այնպես, ինչպես socket-ային գործողությունները։ Ֆայլ կարդալը որոշ չափով նման է page fault-ի։ Այդ պատճառով ֆայլերին հասանելիության յուրաքանչյուր kernel API ի վերջո blocking է (սկզբում սահմանված իմաստով)։

select-ը, որը լուծեց մեր socket-ների խնդիրները, անօգուտ է տեղական ֆայլերի descriptor-ների հետ. դրանք անմիջապես հաշվվում են որպես «պատրաստ»։ Իսկ epoll/aio-ն տեղական ֆայլերի հետ ընդհանրապես չի կարող օգտագործվել։ Ո՛չ Java-ն, ո՛չ որևէ այլ runtime չի կարող այս կանչերը դարձնել non-blocking։

Արդյո՞ք io_uring-ը կփրկի իրավիճակը

Գուցե հանդիպել եք io_uring-ին. դա kernel-ի վերջերս ավելացված հնարավորություն է, որը ստեղծված է հատուկ I/O-ի ցանկացած տեսակի, հատկապես տեղական ֆայլերի հետ գործողությունների համար միասնական ասինխրոն API առաջարկելու նպատակով։ Չէ՞ր կարող Loom-ը օգտվել դրանից։

Կարող էր, և ամենայն հավանականությամբ կօգտվի (հավանաբար միայն տեղական ֆայլերի համար, քանի որ io_uring-ի արդյունավետության առավելությունը epoll-ի նկատմամբ կայուն չէ, և իրականացումն ինքը պարբերաբար տառապում է անվտանգության խոցելիություններից)։ Սակայն դա խնդիրը լոկ տեղափոխում է այլ տեղ, այլ ոչ թե ամբողջությամբ լուծում։

Հավելվածը տեսնում է ֆայլերին դիմելու non-blocking, ասինխրոն API։ Սակայն io_uring-ի ներսում տեղի ունեցողին նայելիս պարզվում է, որ այն պահում է thread pool blocking գործողությունների համար, ինչպիսիք են տեղական ֆայլերի գործողությունները։ Այսպիսով՝ փոխարենը JVM-ը փոխհատուցող thread-եր աշխատեցնի, մենք ստանում ենք io_uring-ի գործարկած և կառավարվող thread-եր։

Սա ազդում է կոնֆիգուրացիայի վրա։ Ձեր հավելվածի օգտագործած kernel thread-երի թիվը սահմանափակելու համար ստիպված կլինեք կարգավորել և՛ JVM-ի carrier thread pool-ը, և՛ io_uring-ը՝ սահմանափակելով վերջինիս գործարկած thread-երի առավելագույն թիվը։ Բարեբախտաբար, հիանալի հոդված ճշգրտորեն բացատրում է, թե ինչպես դա անել։

Արդյո՞ք մեզ պետք է միասնական I/O ինտերֆեյս

Այժմ պարզ է, որ I/O գործողությունները նույնը չեն. երկու ամենահաճախակի տեսակները՝ ցանցային socket-ների և տեղական ֆայլերի հետ աշխատանքը, kernel-ի մակարդակում իրենց տարբեր են պահում։ io_uring-ի նման ջանքերը կարող են միասնական ինտերֆեյս նպատակ ունենալ, բայց հիմքում I/O-ի մի տեսակը non-blocking է, իսկ մյուսը blocking է և կաշխատի thread pool-ում։

Հաշվի առնելով, որ I/O գործողությունների երկու տեսակներն ունեն տարբեր բնութագրեր, արդյո՞ք միասնական ինտերֆեյսը խելամիտ է։ Արդյո՞ք սա leaky abstraction չէ։

Daniel Spiewak-ը հենց այս թեմայով հետաքրքիր առցանց քննարկում սկսեց։ Daniel-ի փաստարկն այն է, որ քանի որ ֆայլերն ու socket-ները տարբեր կերպ են արգելափակվում, այդ տարբերությունը չպետք է թաքցվի io_uring-ի կամ Loom-ի virtual thread-երի նման աբստրակցիայի շերտի հետևում, այլ ավելի շուտ պետք է տեսանելի դարձվի մշակողին։ Պատճառն այն է, որ դրանք պետք է օգտագործվեն տարբեր օրինաչափություններով, և յուրաքանչյուր blocking կանչ պետք է խմբավորվի (batch) և պահպանվի gateway-ի միջոցով, օրինակ՝ սեմաֆորով կամ հերթով։

Իսկ ես, ընդհակառակը, կպնդեի, որ non-blocking I/O-ն, ինչպես socket-ների դեպքում, նույնպես անվճար չէ։ Այն կարող է ավելի էժան լինել, քան blocking I/O-ն, բայց մեր կոդը պետք է պատշաճ կերպով սահմանափակի I/O-ի յուրաքանչյուր տեսակի օգտագործումը։ Յուրաքանչյուր տեսակի գործողության համար սահմանվող concurrency-ի կոնկրետ սահմանները կարող են տարբերվել, բայց դրանք, այնուամենայնիվ, պետք է գոյություն ունենան։

Բնականաբար, կարևոր է նախապես իմանալ, թե I/O գործողության յուրաքանչյուր տեսակն ինչպես է իրեն պահում։ Այսպիսով՝ Daniel-ը իրավացի է, որ նման միասնական ինտերֆեյսը կարող է բարդացնել գործը. առաջին հայացքից պարզ չէ (օրինակ՝ տիպերի համակարգը օգնություն չի տալիս), թե տվյալ գործողությունը runtime-ում ինչպես կվարվի։

Որքա՞ն վերահսկողություն ենք ուզում

Daniel-ը նաև իրավացիորեն նշում է, որ blocking/non-blocking տարբերությունը իրականում կարևոր է միայն բարձր բեռի դեպքում, բայց դա կարող է լինել հենց այն մասշտաբը, որտեղ async-ը կամ Loom/io_uring-ը առհասարակ կարևոր են։ Եվ այդ մասշտաբում կարող եք ուզել ճշգրտորեն իմանալ, թե ինչ է նշանակում որոշակի մեթոդ կանչելը։

Նա եզրափակում է փիլիսոփայական հարցով այն մասին, թե որքան խստորեն պետք է runtime-ը հարգի օգտատիրոջ հարցումները։ Կարողանա՞նք ասել «կատարիր այս I/O գործողությունն առանց արգելափակման», և եթե դա հնարավոր չէ (ասենք, քանի որ խոսքը տեղական ֆայլի մասին է), արդյո՞ք ամբողջ կանչը պետք է ձախողվի։ Թե՞ runtime-ը միշտ պետք է փորձի հնարավորինս կատարել մեր հարցումները՝ անկախ գնից։

Հնարավոր պատասխաններից մեկը capability-ների հիերարխիկ համակարգն է, որն առաջարկում է և՛ մանրամասն BlockingIO և NonBlockingIO capability-ներ, և՛ ավելի ընդհանուր IO-ներ։ Այդ դեպքում տիպերի համակարգը կարող է մեզ ուղղորդել յուրաքանչյուր դեպքը ճիշտ մշակելու, ներառելով և՛ դրա ձախողման եղանակները, և՛ runtime բնութագրերը։

Ամփոփելով

Ահա մի քանի բան, որ սովորեցինք ճանապարհին.

  • Տարբերությունը carrier և virtual thread-երի միջև, և այն, որ Loom-ը շատ virtual thread-եր աշխատեցնում է carrier thread-երի փոքր pool-ի վրա։
  • Loom-ի մի մասը blocking գործողությունների հարմարեցումն է, որպեսզի դրանք «տեղյակ» դառնան virtual thread-երին։
  • Concurrency-ի պրիմիտիվները, ինչպիսիք են lock-երը և սեմաֆորները, ինչպես նաև socket-ների վրա հիմնված ցանցային փոխանակումը տեղափոխվել են՝ virtual thread-երի հետ ճիշտ աշխատելու համար։
  • Սակայն դա չի վերաբերում JDK-ի յուրաքանչյուր blocking API-ին։ Երբ carrier thread-ը արգելափակվում է, գործ ունենք thread-ի ամրացման հետ։
  • Thread-ի ամրացում տեղի է ունենում synchronized հիմնաբառի դեպքում, ինչպես նաև ֆայլային I/O-ի, datagram socket-ների օգտագործման և դոմենային անունների լուծման ժամանակ։
  • Thread-երի ամրացումից խուսափելու եղանակներ կան. synchronized-ը lock-երով փոխարինելը և փոխհատուցող carrier thread-եր գործարկելը։ JDK-ն վերջինս անում է ինքնուրույն (մինչև կարգավորված սահմանը), երբ կանչվում է carrier thread-ը արգելափակող I/O գործողություն։
  • Որոշ գործողություններ, օրինակ՝ ֆայլային I/O-ն, kernel-ի մակարդակում իրենց էությամբ blocking են, և Loom-ը չի կարող դրանք դարձնել non-blocking։
  • io_uring-ը խնդիրը լուծում է միայն մասամբ, քանի որ ներքուստ հենվում է thread pool-ի վրա՝ blocking գործողություններ (օրինակ՝ ֆայլային I/O) կատարելու համար։

Մենք ավարտեցինք բաց հարցով. քանի որ ոչ մի runtime կամ API չի կարող ապահովել իսկապես ունիվերսալ non-blocking I/O, արդյո՞ք խելամիտ է ունենալ աբստրակցիա, որն առաջարկում է մեկ միասնական ինտերֆեյս յուրաքանչյուր blocking և non-blocking գործողության համար։

Պատասխանը կարող է լինել «կախված է»։ Որոշակի մասշտաբից հետո այս մանրամասները սկսում են կարևոր լինել։ Ավելի փոքր մասշտաբներում դրանք կարող են անկարևոր լինել։ Loom-ի կամ io_uring-ի նման աբստրակցիաները leaky են և կարող են մոլորեցնել։ Գուցե տիպերի համակարգի որոշ ուղղորդում կօգներ։ Կամ գուցե այս տեղեկությունը կարելի է այլ կերպ փոխանցել։ Վերջապես, գուցե ուզենք runtime-ներին ասելու միջոց ունենալ, որ ձախողվեն, երբ I/O գործողությունը չի կարող կատարվել որոշակի ձևով։

Loom-ը JVM-ին զգալիորեն առաջ է մղում և հասնում է արդյունավետության իր նպատակներին՝ պարզեցնելով ծրագրավորման մոդելը. սակայն չենք կարող կուրորեն հույս դնել, որ այն կվերացնի kernel thread-երի արգելափակման յուրաքանչյուր աղբյուրը մեր հավելվածներից։ Այն նույնիսկ կարող է մեր հավելվածներում նոր արդյունավետության խնդիրներ ներմուծել՝ մյուսները լուծելիս։

Ի՞նչ եք կարծում սրա մասին. արդյո՞ք blocking և non-blocking գործողությունները պետք է տարբերակվեն։ Իսկ եթե այո, ապա ինչպես՝ տիպերի մակարդակո՞ւմ, անվանակարգման կանոնո՞վ, թե որևէ այլ կերպ։ Ի՞նչ կոնֆիգուրացիա պետք է առաջարկեն մեր runtime-ները, որպեսզի հաստատ իմանանք, թե որոշակի I/O գործողությունն ինչպես կաշխատի։