Java-ի Structured Concurrency և Scoped Values
JEP-505-ի վրա կատարված աշխատանքի շնորհիվ Java 25-ը բերում է structured concurrency։ Այս հոդվածը, թարմացված 2025 թվականի սեպտեմբերին, բացատրում է structured concurrency-ի գաղափարը, հակադրում այն գոյություն ունեցող API-ին և դիտարկում այն խնդիրները, որոնց անդրադառնում է։
JEP-533-ի վրա կատարված աշխատանքի շնորհիվ Java 25-ը բերում է structured concurrency։ Այս հոդվածը, թարմացված 2025 թվականի սեպտեմբերին, բացատրում է structured concurrency-ի գաղափարը, հակադրում այն գոյություն ունեցող API-ին և դիտարկում այն խնդիրները, որոնց անդրադառնում է։
Այս հոդվածը թարմացում է ստացել 2026 թվականի սեպտեմբերի 9-ին։
Ի՞նչ է structured concurrency-ն
Structured concurrency-ի դեպքում յուրաքանչյուր ենթաառաջադրանք կապված է իր ծնող առաջադրանքի scope-ի հետ և չի կարող դրանից ավելի երկար ապրել. նույն կերպ, ինչպես մեթոդի կանչը չի կարող աշխատել ավելի երկար, քան այն կանչած մեթոդը։
Սա զուգահեռ կոդը դարձնում է շատ ավելի հեշտ հասկանալի. ծնող առաջադրանքի ավարտից հետո որբացած ֆոնային թելեր չեն շարունակում աշխատել, սխալների մշակումը դառնում է ավելի կանխատեսելի, քանի որ ձախողումները կարելի է մշակել մեկ տեղում, և ամբողջ համակարգը ավելի հեշտ է դիտարկել ու դեբագ անել։
Գործնականում այն պաշտպանում է անվերահսկելի concurrency-ի սովորական ծուղակներից, ինչպիսիք են թելերի արտահոսքերը կամ առաջադրանքները, որոնք հավերժ կախված են մնում, ինչը հաճախ հանգեցնում է փխրուն, դժվար սպասարկվող համակարգերի։
Java-ում structured concurrency-ն աշխատում է Project Loom-ի ներմուծած վիրտուալ թելերի հետ։ Քանի որ վիրտուալ թելերը չափազանց թեթև են, նոր առաջադրանքներ ստեղծելը գրեթե ոչինչ չարժե, ինչը այս մոտեցումը պահում է գործնական և արդյունավետ նույնիսկ խիստ զուգահեռ հավելվածներում։
Օրինակ. հաշիվ-ապրանքագրի գեներացում structured concurrency-ով
Գոյություն ունեցող API-ի թերությունները ցույց տալու համար վերցնենք պարզ օրինակ՝ հաշիվ-ապրանքագրի ստեղծում։ Պետք է ստանալ թողարկողին, հաճախորդին և իրերի ցանկը։ Դա մեկը մյուսի հետևից մեկ թելի վրա անելը աշխատում է, բայց դանդաղ։ Ավելի լավ կլիներ տվյալները ստանալ զուգահեռաբար։
Սկսենք՝ նայելով, թե ինչպես է դա արվում ExecutorService-ով։
(Ոչ) structured concurrency
Invoice generateInvoice() throws ExecutionException, InterruptedException {
try (final var executor = Executors.newFixedThreadPool(3)) {
Future<Issuer> issuer = executor.submit(this::findIssuer);
Future<Customer> customer = executor.submit(this::findCustomer);
Future<List<Item>> items = executor.submit(this::findItems);
return new Invoice(issuer.get(), customer.get(), items.get());
}
}
Այս մոտեցումը մի քանի խնդիր ունի.
- Եթե
findCustomer-ը աշխատում է ավելի երկար, քանfindItems-ը, ևfindItems-ը բացառություն է նետում,
կոդը կարգելափակվիcustomer.get()-ի վրա, մինչևfindCustomer-ը աշխատեցնող թելը ավարտվի։ Այսպիսով, մենք ռեսուրսներ ենք վատնում այդ ենթաառաջադրանքի ավարտին սպասելով։ - Եթե
generateInvoice()-ը կանչող թելը ընդհատվի, executor-ի ենթաառաջադրանքները չեն ընդհատվում և արտահոսում են։
Դրանք կարող են նույնիսկ անվերջ շարունակել աշխատել՝ անվերահսկելիորեն։
Structured concurrency
Invoice generateInvoice() throws InterruptedException, ExecutionException {
try (var scope = StructuredTaskScope.open(
StructuredTaskScope.Joiner.allSuccessfulOrThrow() // (1)
)) {
Subtask<Issuer> issuer = scope.fork(this::findIssuer);
Subtask<Customer> customer = scope.fork(this::findCustomer);
Subtask<List<Item>> items = scope.fork(this::findItems);
scope.join(); // (2)
return new Invoice(issuer.get(), customer.get(), items.get());
}
}
- (1).
open()factory մեթոդի միջոցով ստեղծվում է նորStructuredTaskScopeallSuccessfulOrThrow()քաղաքականությամբ։
ԵթեfindIssuer-ը,findCustomer-ը կամfindItems-ը բացառություն նետեն, մնացած ենթաառաջադրանքները չեղարկվում են, և scope-ը ձախողվում է։ - (2). Արգելափակում է, մինչև scope-ի բոլոր ենթաառաջադրանքները ավարտվեն, և բացառություն է նետում, եթե դրանցից որևէ մեկը ձախողվել է։
Նկատի ունեցեք, որ լռելյայնscope.join()-ը նետում էExecutionException, երբ ենթաառաջադրանքներից մեկը ձախողվում է։ Սակայն կարող ենք այն կարգավորել նետելու մեր ընտրած ցանկացած հատուկ բացառություն։ Դա պահանջում է փոքր ճշգրտում (1) տողում. կանչելStructuredTaskScope.Joiner.allSuccessfulOrThrow(MyCustomException::new)։ Այդ դեպքում մենք նաև պետք է հայտարարենքMyCustomException-ըgenerateInvoice() throwsկետում՝ լռելյայնExecutionException-ի փոխարեն։
Վերևի կոդը չի տառապում նախկինում նկարագրված խնդիրներից.
- Եթե
findCustomer-ը աշխատում է ավելի երկար, քանfindItems-ը, բայցfindItems-ը բացառություն է նետում, ավելի երկար աշխատող առաջադրանքը չեղարկվում է։ - Եթե
generateInvoice()-ը կանչող թելը ընդհատվում է, չեղարկումը տարածվում է ենթաառաջադրանքների վրա։ - Յուրաքանչյուր ենթաառաջադրանք ավարտվում է մինչև scope-ից դուրս գալը։
Առաջին հայացքից քիչ բան է տարբեր թվում. StructuredTaskScope-ը փոխարինում է ExecutorService-ին, և քանի որ երկուսն էլ իրականացնում են AutoCloseable, try-with-resources-ը աշխատում է երկուսի համար։ Տարբերությունը, սակայն, կարևոր է. ExecutorService-ը սովորաբար հենվում է platform թելերի վրա, մինչդեռ StructuredTaskScope-ն օգտագործում է Loom նախագծի թեթև վիրտուալ թելերը։ Բացի այդ, ExecutorService-ը վերադարձնում է Future<T>, իսկ այստեղ գործ ունենք Subtask<T>-ի հետ։
Structured concurrency-ի քաղաքականությունները
Քաղաքականությունը կանոնների հավաքածու է, որը սահմանում է, թե ինչպես է StructuredTaskScope-ը արձագանքում, երբ նրա ենթաառաջադրանքները հաջողվում կամ ձախողվում են։
Նոր API-ն դրանք իրականացնում է որպես Joiner-ներ։
allSuccessfulOrThrow
Երբ որևէ ենթաառաջադրանք ձախողվում է, մյուսները չեղարկվում են, և scope-ը ձախողվում է։ Սա լավ հարմար է մեր հաշիվ-ապրանքագրի օրինակին. տվյալների յուրաքանչյուր մաս պետք է առկա լինի։
anySuccessfulOrThrow
Հենց որ մեկ ենթաառաջադրանք հաջողվում է, մնացածը կանգնեցվում են. եթե բոլորը ձախողվում են, բացառություն է նետվում։ Սա օգտակար է, երբ նույն տվյալների համար հարցում եք անում մի քանի աղբյուրի, և կարևոր է միայն ամենաարագը. դասական race condition սցենար։
allUntil
Պահում է բոլոր ենթաառաջադրանքները աշխատող, մինչև պայմանը բավարարվի, ապա չեղարկում է մնացածը։
Այլ քաղաքականություններ
Անհրաժեշտության դեպքում կարող եք գրել ձեր սեփական քաղաքականությունը՝ իրականացնելով հատուկ StructuredTaskScope.Joiner<T, R, R_X extends Throwable>։
Scoped values (տիրույթով սահմանափակված արժեքներ)
Scoped values-ը տրամադրում է պարզ և անվտանգ եղանակ անփոփոխ տվյալները մեթոդների և երեխա թելերի միջև համօգտագործելու համար։ Դրանք ավելի հեշտ են հասկանալի, քան ThreadLocal-ը, և ավելի էժան, հատկապես վիրտուալ թելերի և structured concurrency-ի հետ համադրված։
JDK 25-ում (JEP 506) scoped values API-ն վերջնական է։ Preview-ներից կա մեկ փոքր տարբերություն. orElse մեթոդն այլևս null չի ընդունում։
Օրինակ. հարցման ID լոգավորման մեջ
import java.util.concurrent.StructuredTaskScope;
import java.util.concurrent.StructuredTaskScope.Joiner;
import static java.lang.ScopedValue.where;
public class LoggerExample {
private static final ScopedValue<String> REQUEST_ID =
ScopedValue.newInstance();
static void main() throws InterruptedException, ExecutionException {
try (var scope = StructuredTaskScope
.open(Joiner.allSuccessfulOrThrow())) {
scope.fork(() -> where(REQUEST_ID, "abc-123")
.run(Main::handleRequest));
scope.fork(() -> where(REQUEST_ID, "xyz-789")
.run(Main::handleRequest));
scope.join();
}
}
static void handleRequest() {
log("handleRequest: start");
try (var scope = StructuredTaskScope
.open(Joiner.allSuccessfulOrThrow())) {
scope.fork(Main::queryDatabase);
scope.fork(Main::callExternalService);
scope.join();
} catch (InterruptedException | ExecutionException e) {
throw new RuntimeException(e);
}
log("handleRequest: done");
}
static void queryDatabase() {
log("Querying database...");
}
static void callExternalService() {
log("Calling external service...");
}
static void log(String message) {
String rid = REQUEST_ID.isBound() ?
REQUEST_ID.get() : "<unbound>";
System.out.println("[" + rid + "] " + message);
}
}
- Հայտարարվում է REQUEST_ID scoped value-ն՝ հարցման նույնացուցիչը պահելու համար։
- main()-ի ներսում fork են արվում երկու առաջադրանք, և յուրաքանչյուրը REQUEST_ID-ն կապում է իր սեփական արժեքին (abc-123, xyz-789)։
- handleRequest-ը բացում է structured scope և զուգահեռաբար կատարում ենթաառաջադրանքները. յուրաքանչյուր ենթաառաջադրանք ավտոմատ տեսնում է ճիշտ կապված հարցման ID-ն։
- log մեթոդը REQUEST_ID-ն փնտրում է դինամիկորեն, ուստի յուրաքանչյուր հաղորդագրություն կրում է ճիշտ հարցման ID-ն՝ առանց այն որպես արգումենտ փոխանցելու։
Օրինակ ելք.
[xyz-789] handleRequest: start
[abc-123] handleRequest: start
[abc-123] Querying database...
[xyz-789] Querying database...
[xyz-789] Calling external service...
[xyz-789] handleRequest: done
[abc-123] Calling external service...
[abc-123] handleRequest: done
Սա ցույց է տալիս, թե ինչպես scoped values-ը թույլ են տալիս համատեքստին մաքուր և արդյունավետ հոսել կանչերի շղթայով և ներքև՝ ենթաառաջադրանքների մեջ։
Ամփոփում
Structured concurrency-ն և scoped values-ը արժեքավոր հավելում են Java-ի ստանդարտ API-ին՝ զուգահեռ կոդը գրելը դարձնելով ավելի պարզ։
- Structured concurrency (JEP 533)-ը թույլ է տալիս ենթաառաջադրանքների խումբը մշակել որպես աշխատանքի մեկ միավոր՝ կանխատեսելի չեղարկմամբ և սխալների մշակմամբ։
- Scoped values (JEP 506)-ը առաջարկում են արդյունավետ, անվտանգ եղանակ անփոփոխ համատեքստային տվյալները մեթոդների և թելերի միջև համօգտագործելու համար, ազատ
ThreadLocal-ի հետ կապված խնդիրներից։