Java-da iki iplik arasında məlumat mübadiləsini necə…

Java-da axınlar arasında məlumat mübadiləsini aşağıdakı üsullarla təşkil etmək mümkündür:

Ümumi dəyişənlər və sinxronizasiya: Axınlar ümumi dəyişənlərdən istifadə edir və bunlara giriş synchronized açar sözü, bloklar (Lock java.util.concurrent.locks-dən) və ya atomik dəyişənlər (Atomic java.util.concurrent.atomic-dən) vasitəsilə sinxronizasiya olunur.

Data pipeləri (Piped Streams): Bağlı giriş/çıxış axınları (PipedInputStream və PipedOutputStream) bir axının məlumat yazmasına, digərinin isə oxumasına imkan verir.

// Piped Streams istifadə
try {
    PipedOutputStream pout = new PipedOutputStream();
    PipedInputStream pin = new PipedInputStream(pout);

    // Axın 1: yazma
    new Thread(() -> {
        try {
            pout.write("Salam axın 1-dən".getBytes());
            pout.close();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }).start();

    // Axın 2: oxuma
    new Thread(() -> {
        try {
            int data;
            while ((data = pin.read()) != -1) {
                System.out.print((char) data);
            }
            pin.close();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }).start();
} catch (Exception e) {
    e.printStackTrace();
}

Sıralar (Queues): BlockingQueue kimi çox təhlükəsiz kolleksiyaların istifadəsi, məsələn, ArrayBlockingQueue, LinkedBlockingQueue, bir axının elementləri yerləşdirməsinə və digərinin isə çıxarmasına imkan verir.

import java.util.concurrent.BlockingQueue;
import java.util.concurrent.LinkedBlockingQueue;

// BlockingQueue istifadə
BlockingQueue<String> queue = new LinkedBlockingQueue<>();

// İstehsalçı
new Thread(() -> {
    try {
        queue.put("Mesaj 1");
        queue.put("Mesaj 2");
    } catch (InterruptedException e) {
        Thread.currentThread().interrupt();
    }
}).start();

// İstifadəçi
new Thread(() -> {
    try {
        System.out.println(queue.take());
        System.out.println(queue.take());
    } catch (InterruptedException e) {
        Thread.currentThread().interrupt();
    }
}).start();

wait(), notify(), notifyAll() mexanizmləri: Obeyektin monitorlərinə əsaslanan sinxronizasiya üçün istifadə olunur. Bir axın wait() çağırır ki, şərti gözləsin, digər axın isə notify() və ya notifyAll() çağıraraq gözləyən axınlara şərti dəyişdiyini bildirir.

// wait/notify istifadə
class Data {
    private String message;
    private boolean empty = true;

    public synchronized String read() {
        while (empty) {
            try {
                wait(); // Gözləyirik məlumatları
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
        }
        empty = true;
        notifyAll(); // Yazma imkanını bildir
        return message;
    }

    public synchronized void write(String message) {
        while (!empty) {
            try {
                wait(); // Əvvəlki məlumatlar oxunana qədər gözləyirik
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
        }
        empty = false;
        this.message = message;
        notifyAll(); // Yeni məlumatların olduğunu bildir
    }
}

CompletableFuture: Asinxron hesablama yaratmağa və nəticələrini birləşdirməyə imkan verir, məlumat mübadiləsini geri qaytarılan dəyərlər və tamamlanma idarəediciləri vasitəsilə təmin edir.
Exchanger: İki axının obyektləri sinxronizasiya nöqtəsində dəyişməsinə imkan verir.

Xüsusi metodun seçimi tapşırığın xüsusiyyətlərinə, tələb olunan sinxronizasiya səviyyəsinə, performansa və həyata keçirilmə çətinliyinə bağlıdır.

Java-da iki iplik arasında məlumat mübadiləsini necə təşkil etmək olar?