面试高频知识点：2线程 2.1.6线程之间如何通信

线程之间的通信方式

在Java中，常见的线程之间通信方式包括：

1. 共享内存：通过共享内存区域进行通信，即多个线程共享同一块内存区域。通常需要使用同步机制来保护共享数据的一致性。

2. 消息传递：通过消息传递的方式进行通信，即线程之间通过发送和接收消息来进行信息交换。

下面将分别介绍这两种通信方式，并提供示例代码。

共享内存通信方式

共享内存通信方式是通过共享内存区域进行数据交换的方式。在Java中，可以使用共享对象（例如共享变量）来实现线程之间的通信。常见的共享内存通信方式包括：

• 使用synchronized关键字对共享变量进行同步；
• 使用volatile关键字保证共享变量的可见性；
• 使用Lock和Condition等并发工具类进行线程同步。

下面是一个使用synchronized关键字实现的示例：

class SharedObject {
    private int sharedData;

    public synchronized void setSharedData(int data) {
        sharedData = data;
        notify(); // 通知等待中的线程
    }

    public synchronized int getSharedData() throws InterruptedException {
        while (sharedData == 0) {
            wait(); // 等待数据被设置
        }
        return sharedData;
    }
}

class Producer extends Thread {
    private SharedObject sharedObject;

    public Producer(SharedObject sharedObject) {
        this.sharedObject = sharedObject;
    }

    @Override
    public void run() {
        sharedObject.setSharedData(1);
    }
}

class Consumer extends Thread {
    private SharedObject sharedObject;

    public Consumer(SharedObject sharedObject) {
        this.sharedObject = sharedObject;
    }

    @Override
    public void run() {
        try {
            int data = sharedObject.getSharedData();
            System.out.println("Consumer received data: " + data);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

public class SharedMemoryCommunicationExample {
    public static void main(String[] args) {
        SharedObject sharedObject = new SharedObject();
        Producer producer = new Producer(sharedObject);
        Consumer consumer = new Consumer(sharedObject);

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

消息传递通信方式

消息传递通信方式是通过发送和接收消息来进行线程间的通信。在Java中，可以使用wait、notify和notifyAll方法实现线程之间的消息传递。也可以使用阻塞队列（如LinkedBlockingQueue）等并发容器来进行消息传递。

下面是一个使用wait和notify方法实现的示例：

class Message {
    private String content;

    public synchronized void setContent(String content) {
        this.content = content;
        notify(); // 通知等待中的线程
    }

    public synchronized String getContent() throws InterruptedException {
        while (content == null) {
            wait(); // 等待消息被设置
        }
        return content;
    }
}

class Sender extends Thread {
    private Message message;

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

    @Override
    public void run() {
        message.setContent("Hello, Receiver!");
    }
}

class Receiver extends Thread {
    private Message message;

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

    @Override
    public void run() {
        try {
            String receivedContent = message.getContent();
            System.out.println("Receiver received message: " + receivedContent);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

public class MessagePassingCommunicationExample {
    public static void main(String[] args) {
        Message message = new Message();
        Sender sender = new Sender(message);
        Receiver receiver = new Receiver(message);

        sender.start();
        receiver.start();
    }
}