java如何实现多线程之间的通讯和协作的代码例子

### 回答1：
Java 可以使用 wait()、notify() 和 notifyAll() 方法实现多线程之间的通讯和协作。以下是一个简单的代码例子：

public class ThreadCommunicationExample {
    public static void main(String[] args) {
        Message message = new Message();
        Thread senderThread = new Thread(new Sender(message));
        Thread receiverThread = new Thread(new Receiver(message));
        senderThread.start();
        receiverThread.start();
    }
}

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

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

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

class Sender implements Runnable {
    private Message message;

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

    public void run() {
        String[] messages = {
            "Message 1",
            "Message 2",
            "Message 3",
            "Message 4"
        };

        for (String message : messages) {
            this.message.write(message);
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {}
        }

        this.message.write("Finished");
    }
}

class Receiver implements Runnable {
    private Message message;

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

    public void run() {
        while (true) {
            String message = this.message.read();
            if (message.equals("Finished")) {
                break;
            }
            System.out.println("Received message: " + message);
        }
    }
}

在这个例子中，Sender 线程向 Message 对象写入消息，Receiver 线程从 Message 对象中读取消息。Message 对象使用 wait()、notify() 和 notifyAll() 方法实现了多线程之间的通讯和协作。当 Message 对象为空时，Receiver 线程调用 wait() 方法等待 Sender 线程写入消息；当 Message 对象不为空时，Sender 线程调用 wait() 方法等待 Receiver 线程读取消息。当 Sender 线程写入消息时，它调用 notifyAll() 方法通知 Receiver 线程可以读取消息了；当 Receiver 线程读取消息时，它调用 notifyAll() 方法通知 Sender 线程可以写入消息了。

### 回答2：
Java实现多线程之间通讯和协作的方式有多种，下面是一个简单的代码例子：

public class CommunicationExample {
    private static Object lock = new Object(); // 定义一个锁对象

    public static void main(String[] args) {
        ThreadA threadA = new ThreadA();
        ThreadB threadB = new ThreadB();

        threadA.start();
        threadB.start();
    }

    static class ThreadA extends Thread {
        @Override
        public void run() {
            synchronized (lock) { // 获取锁
                for (int i = 1; i <= 10; i++) {
                    System.out.println("ThreadA: " + i);
                    try {
                        lock.notify(); // 唤醒等待中的ThreadB
                        lock.wait(); // 释放锁并等待
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                lock.notify(); // 唤醒ThreadB，以结束循环
            }
        }
    }

    static class ThreadB extends Thread {
        @Override
        public void run() {
            synchronized (lock) { // 获取锁
                try {
                    lock.wait(); // 等待ThreadA先执行
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }

                for (int i = 1; i <= 10; i++) {
                    System.out.println("ThreadB: " + i);
                    try {
                        lock.notify(); // 唤醒等待中的ThreadA
                        lock.wait(); // 释放锁并等待
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                lock.notify(); // 唤醒ThreadA，以结束循环
            }
        }
    }
}

以上代码中，我们通过`synchronized`关键字来实现线程之间的互斥访问，使用`wait()`和`notify()`方法实现线程之间的通信和协作。具体来说：

1. 我们定义了一个共享的锁对象`lock`。
2. 在`ThreadA`中的`run()`方法中，通过`synchronized (lock)`来获取锁，执行打印操作后，调用`lock.notify()`唤醒正在等待的`ThreadB`，然后调用`lock.wait()`释放锁并等待。
3. 在`ThreadB`中的`run()`方法中，首先调用`lock.wait()`等待`ThreadA`的唤醒，然后执行打印操作后，调用`lock.notify()`唤醒正在等待的`ThreadA`，最后调用`lock.wait()`释放锁并等待。
4. 循环上述步骤，直到完成任务。

这样就实现了`ThreadA`和`ThreadB`之间的通信和协作，它们交替打印输出的结果类似于：

ThreadA: 1
ThreadB: 1
ThreadA: 2
ThreadB: 2
...
ThreadA: 10
ThreadB: 10

### 回答3：
Java中可以通过以下方式实现多线程之间的通信和协作：

1. 等待/通知机制：使用Object类的wait()和notify()方法来实现线程的等待和唤醒。一个线程可以调用wait()方法使自己进入等待状态，等待其他线程调用同一个对象的notify()方法来唤醒它。下面是一个简单的例子：

public class ThreadCommunicationExample {
    public static void main(String[] args) {
        final Object lock = new Object();
        final boolean[] flag = {false}; // 用于通信的标志
        
        Thread thread1 = new Thread(() -> {
            synchronized (lock) {
                try {
                    while (!flag[0]) {
                        lock.wait(); // 线程等待
                    }
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("Thread 1 is working...");
            }
        });
        
        Thread thread2 = new Thread(() -> {
            synchronized (lock) {
                flag[0] = true;
                lock.notify(); // 唤醒等待的线程
                System.out.println("Thread 2 is working...");
            }
        });
        
        thread1.start();
        thread2.start();
    }
}

2. 使用线程的join()方法：join()方法可以使一个线程等待另一个线程完成后再继续执行。下面是一个使用join()方法的例子：

public class ThreadCommunicationExample {
    public static void main(String[] args) {
        Thread thread1 = new Thread(() -> {
            System.out.println("Thread 1 is working...");
        });

        Thread thread2 = new Thread(() -> {
            try {
                thread1.join(); // 等待thread1执行完毕
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("Thread 2 is working...");
        });

        thread1.start();
        thread2.start();
    }
}

这是两种常用的多线程通信和协作的方式，使用等待/通知机制或join()方法可以实现线程之间的有效沟通和协作。实际应用中，可以根据具体需求选择合适的方式来实现多线程间的通讯和协作。