1class SampleThread extends Thread {
2    private int result;
3
4    public void run() {
5        // Perform some computation
6        result = 100;
7        System.out.println("Result from other thread: " + result);
8    }
9
10    public int getResult() {
11        return result;
12    }
13}
14
15public class MainThread {
16    public static void main(String[] args) {
17        SampleThread sampleThread = new SampleThread();
18        sampleThread.start();
19
20        try {
21            sampleThread.join(); // main thread waits for sampleThread to finish
22        } catch (InterruptedException e) {
23            e.printStackTrace();
24        }
25
26        // Use the result from sampleThread
27        System.out.println("Processed result: " + sampleThread.getResult());
28    }
29}

1class SharedData {
2    private int result;
3    private volatile boolean isResultReady = false;
4
5    public synchronized void produce() {
6        result = 200;
7        isResultReady = true;
8        notify(); // Signal that the result is ready
9    }
10
11    public synchronized int consume() throws InterruptedException {
12        while (!isResultReady) {
13            wait(); // Wait until the result is ready
14        }
15        return result;
16    }
17}
18
19public class MainThread {
20    public static void main(String[] args) {
21        SharedData sharedData = new SharedData();
22
23        Thread producer = new Thread(() -> sharedData.produce());
24        Thread consumer = new Thread(() -> {
25            try {
26                int result = sharedData.consume();
27                System.out.println("Result from producer: " + result);
28            } catch (InterruptedException e) {
29                e.printStackTrace();
30            }
31        });
32
33        producer.start();
34        consumer.start();
35    }
36}

1import java.util.concurrent.CountDownLatch;
2
3public class MainThread {
4    public static void main(String[] args) {
5        CountDownLatch latch = new CountDownLatch(1);
6
7        Runnable worker = () -> {
8            try {
9                System.out.println("Worker thread doing work...");
10                Thread.sleep(2000); // Simulating work
11                System.out.println("Worker thread done!");
12            } catch (InterruptedException e) {
13                e.printStackTrace();
14            }
15            latch.countDown(); // Signal that the worker has completed
16        };
17
18        new Thread(worker).start();
19
20        try {
21            System.out.println("Main thread waiting for worker thread to finish...");
22            latch.await(); // Wait until the latch reaches zero
23            System.out.println("Worker thread has completed. Main thread resumes.");
24        } catch (InterruptedException e) {
25            e.printStackTrace();
26        }
27    }
28}