इंटर थ्रेड कम्युनिकेशन-जावा

क्या आप ऐसा कुछ करने की कोशिश कर रहे हैं? यदि आप वास्तव में प्रतीक्षा / सूचना का उपयोग करना चाहते हैं और Runnable का उपयोग करना चाहते हैं।

मैंने एक प्रतीक्षा खंड जोड़ा है, अन्यथा मुख्य धागा पृष्ठभूमि थ्रेड मूल्य में वृद्धि से पहले समाप्त हो सकता है।

class Foo implements Runnable {
    public volatile int value = 0, i = 0;
    private Thread backgroundThread;

    public void setThread(Thread thread) {
        this.backgroundThread = thread;
    }

    @Override
    public void run() {
        synchronized (backgroundThread) {
            while (i < 2) {
                value++;
                i++;
                backgroundThread.notify();
                try {
                    System.out.println("background thread wait start");
                    backgroundThread.wait();
                    System.out.println("background thread notified");
                } catch (InterruptedException ex) {
                    ex.printStackTrace();
                }
            }
        }
    }

    public int getValue() {
        try {
            Thread.sleep(1000);
        } catch (Exception e) {
            e.printStackTrace();
        }
        return value;
    }
}

public class ThreadTest {
    public static int value1, times = 0;

    public static void main(String[] args) {
        Foo foo = new Foo();
        final Thread thread = new Thread(foo);
        foo.setThread(thread);
        thread.start();

        while (times < 3) {
            synchronized (thread) {
                value1 = foo.getValue();
                times++;
                System.out.println(value1);
                System.out.println(thread.getState());
                thread.notify();
                try {
                    thread.wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

या आप थ्रेड का विस्तार कर सकते हैं:

class BackgroundThread extends Thread {
    public volatile int value = 0, i = 0;

    @Override
    public synchronized void run() {
        while (i < 2) {
            value++;
            i++;
            notify();
            try {
                System.out.println("background thread wait start");
                wait();
                System.out.println("background thread notified");
            } catch (InterruptedException ex) {
                ex.printStackTrace();
            }
        }
    }

    public int getValue() {
        try {
            Thread.sleep(1000);
        } catch (Exception e) {
            e.printStackTrace();
        }
        return value;
    }
}

public class ThreadTest {
    public static int value1, times = 0;

    public static void main(String[] args) {
        BackgroundThread backgroundThread = new BackgroundThread();
        backgroundThread.start();

        while (times < 3) {
            synchronized (backgroundThread) {
                value1 = backgroundThread.getValue();
                times++;
                System.out.println(value1);
                System.out.println(backgroundThread.getState());
                backgroundThread.notify();
                try {
                    backgroundThread.wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}