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

Java-ի Structured Concurrency և Scoped Values

JEP-505-ի վրա կատարված աշխատանքի շնորհիվ Java 25-ը բերում է structured concurrency։ Այս հոդվածը, թարմացված 2025 թվականի սեպտեմբերին, բացատրում է structured concurrency-ի գաղափարը, հակադրում այն գոյություն ունեցող API-ին և դիտարկում այն խնդիրները, որոնց անդրադառնում է։

5 րոպե
Javastructured concurrencyproject loomuncoverjavajava 25

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 մեթոդի միջոցով ստեղծվում է նոր StructuredTaskScope allSuccessfulOrThrow() քաղաքականությամբ։
    Եթե 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);
    }
}
  1. Հայտարարվում է REQUEST_ID scoped value-ն՝ հարցման նույնացուցիչը պահելու համար։
  2. main()-ի ներսում fork են արվում երկու առաջադրանք, և յուրաքանչյուրը REQUEST_ID-ն կապում է իր սեփական արժեքին (abc-123, xyz-789)։
  3. handleRequest-ը բացում է structured scope և զուգահեռաբար կատարում ենթաառաջադրանքները. յուրաքանչյուր ենթաառաջադրանք ավտոմատ տեսնում է ճիշտ կապված հարցման ID-ն։
  4. 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-ի հետ կապված խնդիրներից։