Ինչպե՞ս կարելի է կազմակերպել տվյալների փոխանակումը…

Դատարկ տվյալների փոխանակումը Java- ում կարող է կազմակերպվել հետևյալ եղանակներով:

Համատեղ փոփոխականներ սինխրոնիզացիայով: Թողարկումները օգտագործում են ընդհանուր փոփոխականներ, որոնց մուտքը սինխրոնիզացվում է synchronized բանալի բառով, արգելափակոցներով (Lock java.util.concurrent.locks-ից) կամ ատոմային փոփոխականներով (Atomic java.util.concurrent.atomic-ից):

Տվյալների կոնվեյերներ (Piped Streams): Կապակցված մուտք/արտահոսքեր (PipedInputStream և PipedOutputStream) թույլ են տալիս մեկ հոսքին գրանցել տվյալներ, իսկ մյուսը՝ կարդալ:

// Piped Streams-ների օգտագործում
փորձեք {
    PipedOutputStream pout = նոր PipedOutputStream();
    PipedInputStream pin = նոր PipedInputStream(pout);

    // Հոսք 1: գրանցում
    նոր Թել (() -> {
        փորձեք {
            pout.write("Բարև, հոսք 1-ից".getBytes());
            pout.close();
        } բռնելով (Exception e) {
            e.printStackTrace();
        }
    }).start();

    // Հոսք 2: կարդալ
    նոր Թել (() -> {
        փորձեք {
            int data;
            մինչ ((data = pin.read()) != -1) {
                System.out.print((char) data);
            }
            pin.close();
        } բռնելով (Exception e) {
            e.printStackTrace();
        }
    }).start();
} բռնելով (Exception e) {
    e.printStackTrace();
}

Հոսքեր (Queues): Օգտագործելով հոսքային անվտանգ հավաքածուներ, ինչպիսիք են BlockingQueue (օրինակ, ArrayBlockingQueue, LinkedBlockingQueue), թույլ է տալիս մեկ հոսքին տեղադրել տարրեր հերթում, իսկ մյուսը՝ հանել:

ներմուծում java.util.concurrent.BlockingQueue;
ներմուծում java.util.concurrent.LinkedBlockingQueue;

// Օգտագործում BlockingQueue
BlockingQueue<String> queue = նոր LinkedBlockingQueue<>();

// Արտադրող
նոր Թել (() -> {
    փորձեք {
        queue.put("Հաղորդագրություն 1");
        queue.put("Հաղորդագրություն 2");
    } բռնելով (InterruptedException e) {
        Thread.currentThread().interrupt();
    }
}).start();

// Կառավարող
նոր Թել (() -> {
    փորձեք {
        System.out.println(queue.take());
        System.out.println(queue.take());
    } բռնելով (InterruptedException e) {
        Thread.currentThread().interrupt();
    }
}).start();

wait(), notify(), notifyAll(): Օգտագործվում են հոսքերի սինխրոնիզացման համար օբյեկտի մոնիտորների վրա: Մեկ հոսք կանչում է wait()՝ սպասելու պայմանին, մյուսը՝ notify() կամ notifyAll()՝ սպասող հոսքերին տեղեկացնելու պայմանի փոփոխության մասին:

// wait/notify օգտագործում
դաս `Data` {
    մասնավոր String message;
    մասնավոր boolean empty = true;

    հանրային սինխրոնիզացված String read() {
        մինչ (empty) {
            փորձեք {
                wait(); // սպասում տվյալների
            } բռնելով (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
        }
        empty = true;
        notifyAll(); // տեղեկացնել հնարավոր գրանցման մասին
        վերադարձնել message;
    }

    հանրային սինխրոնիզացված void write(String message) {
        մինչ (!empty) {
            փորձեք {
                wait(); // սպասում նախորդ տվյալների ընթերցմանը
            } բռնելով (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
        }
        empty = false;
        այս.message = message;
        notifyAll(); // տեղեկացնել նոր տվյալների մասին
    }
}

CompletableFuture: Позволяет создавать асинхронные вычисления и объединять их результаты, обеспечивая обмен данными через возвращаемые значения и обработчики завершения.
Exchanger: Позволяет двум потокам обменяться объектами в точке синхронизации.

Выбор конкретного метода зависит от специфики задачи, требуемого уровня синхронизации, производительности и сложности реализации.

Ինչպե՞ս կարելի է կազմակերպել տվյալների փոխանակումը երկու հոսքերի միջև Java-ում։