JAVA学习-并发.线程之间的协作

        在Java中，线程之间的协作可以通过以下几种方式实现：

1. wait()和notify() / notifyAll()方法：

        这是最基础的线程协作方式。通过Object类的wait()方法使线程进入等待状态，通常是等待某个条件满足；通过notify() / notifyAll()方法唤醒等待的线程。需要注意的是，这些方法必须在同步块中调用，且同步块必须与调用wait() / notify() / notifyAll()的对象相关联。

2. 使用Condition对象：

        Condition是在JDK5中引入的类似于wait()和notify()的机制，但更加灵活。Condition对象是属于Lock接口的一部分，使用Condition可以让线程更精细地控制等待和唤醒的时机。

3. CountDownLatch：

        CountDownLatch是一种多线程协作工具，允许一个或多个线程等待其他线程完成操作。它通过一个计数器来实现，计数器为0时，等待的线程可以继续执行。

4. CyclicBarrier：

        CyclicBarrier也是一种多线程协作工具，它允许一组线程相互等待，直到所有线程都达到某个屏障点时才继续执行。

5. Semaphore：

        Semaphore是一种计数信号量，用于控制同时访问特定资源的线程数量。可以用来实现有限资源池或限制并发线程数等。

6. CompletableFuture：

        CompletableFuture是在JDK8中引入的一个类，用于异步编程。它提供了许多方法来处理异步任务的结果以及不同任务之间的依赖关系，可以通过thenApply、thenAccept等方法实现线程之间的协作。

        相比之下，wait()和notify() / notifyAll()方法是最基础也是最底层的线程协作机制，而CompletableFuture更加高级且方便使用，可以更好地处理异步任务和任务依赖关系。

以下是一个简单的示例代码，演示了使用wait()和notify()方法实现线程之间的协作：

public class ThreadCooperationExample {
    public static void main(String[] args) {
        Message message = new Message();

        Thread producer = new Thread(new Producer(message));
        Thread consumer = new Thread(new Consumer(message));

        producer.start();
        consumer.start();
    }

    static class Message {
        private String message;
        private boolean empty = true;

        public synchronized String read() {
            while (empty) {
                try {
                    wait();
                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt();
                }
            }
            empty = true;
            notifyAll();
            return message;
        }

        public synchronized void write(String message) {
            while (!empty) {
                try {
                    wait();
                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt();
                }
            }
            empty = false;
            this.message = message;
            notifyAll();
        }
    }

    static class Producer implements Runnable {
        private Message message;

        public Producer(Message message) {
            this.message = message;
        }

        @Override
        public void run() {
            String[] messages = {"Message 1", "Message 2", "Message 3"};
            for (String msg : messages) {
                message.write(msg);
                System.out.println("Produced: " + msg);
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt();
                }
            }
            message.write("Done");
        }
    }

    static class Consumer implements Runnable {
        private Message message;

        public Consumer(Message message) {
            this.message = message;
        }

        @Override
        public void run() {
            while (!message.read().equals("Done")) {
                System.out.println("Consumed: " + message.read());
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt();
                }
            }
        }
    }
}

(文章为作者在学习java过程中的一些个人体会总结和借鉴，如有不当、错误的地方，请各位大佬批评指正，定当努力改正，如有侵权请联系作者删帖。)

原文地址：https://blog.csdn.net/weixin_69763181/article/details/137903184

免责声明：本站文章内容转载自网络资源，如本站内容侵犯了原著者的合法权益，可联系本站删除。更多内容请关注自学内容网（zxcms.com）！