Java'da ikki iplik o'rtasida ma'lumot almashishni…

Java'da oqimlar o'rtasida ma'lumot almashishni quyidagi usullar bilan tashkil qilish mumkin:

Siklash bilan umumiy o'zgaruvchilar: O'qimlar umumiy o'zgaruvchilarni ishlatadi, ularning kirish-chiqish synchronized kalit so'zi, bloklar (Lock java.util.concurrent.locks dan) yoki atomik o'zgaruvchilar (Atomic java.util.concurrent.atomic dan) yordamida sinxronlashtiriladi.

Ma'lumot quvurlari (Piped Streams): Bog'langan kirish/chiqish oqimlari (PipedInputStream va PipedOutputStream) bir oqimga ma'lumot yozishga, boshqasi esa ularni o'qishga imkon beradi.

// Piped oqimlar bilan ishlash
try {
    PipedOutputStream pout = new PipedOutputStream();
    PipedInputStream pin = new PipedInputStream(pout);

    // 1-oqim: yozish
    new Thread(() -> {
        try {
            pout.write("Salom, 1-oqimdan".getBytes());
            pout.close();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }).start();

    // 2-oqim: o'qish
    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();
}

Navbatlar (Queues): BlockingQueue kabi xavfsiz kolleksiyalarni ishlatish (masalan, ArrayBlockingQueue, LinkedBlockingQueue) bir oqimga elementlarni joylashtirish, boshqasi esa ularni olish imkonini beradi.

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

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

// Ishlab chiqaruvchi
new Thread(() -> {
    try {
        queue.put("Xabar 1");
        queue.put("Xabar 2");
    } catch (InterruptedException e) {
        Thread.currentThread().interrupt();
    }
}).start();

// Foydalanuvchi
new Thread(() -> {
    try {
        System.out.println(queue.take());
        System.out.println(queue.take());
    } catch (InterruptedException e) {
        Thread.currentThread().interrupt();
    }
}).start();

wait(), notify(), notifyAll() mexanizmlari: Ob'ekt monitorlariga asoslangan holda oqimlarni sinxronlashtirish uchun ishlatiladi. Bir oqim wait() chaqiradi, shunda u kutadi, boshqasi esa notify() yoki notifyAll() chaqiradi, kutayotgan oqimlarga shart o'zgarishini bildirish uchun.

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

    public synchronized String read() {
        while (empty) {
            try {
                wait(); // Ma'lumot kutish
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
        }
        empty = true;
        notifyAll(); // Yozish imkoniyatini bildirish
        return message;
    }

    public synchronized void write(String message) {
        while (!empty) {
            try {
                wait(); // Oldingi ma'lumotlar o'qilishini kutish
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
        }
        empty = false;
        this.message = message;
        notifyAll(); // Yangi ma'lumotlar haqida bildirish
    }
}

CompletableFuture: Asinxron hisoblashlarni yaratish va ularni birlashtirish imkonini beradi, ularni qiymatlar va yakunlash handlerlari orqali ma'lumotlar bilan almashish.
Exchanger: Ikki oqimga obyektlarni almashish uchun imkon beradi.

Maxsus metod tanlovi vazifaning tabiati, talab qilingan sinxronizatsiya darajasi, ishlash tezligi va amalga oshirish murakkabligiga bog'liq.

Java'da ikki iplik o'rtasida ma'lumot almashishni qanday tashkil qilish mumkin?