Java如何实现多个线程之间共享数据

要实现多个线程之间共享数据，Java提供了以下两种方式：

1. 共享引用类型的数据
2. 共享基本类型的数据

共享引用类型的数据

Java中，对象是存储在堆内存中的，每个对象都有一个地址，当多个线程对这个对象引用进行操作时，它们都指向同一个地址，因此它们访问的是同一个对象，所以可以实现数据共享。共享数据的过程中需要注意同步操作，保证线程安全。

示例1：共享对象类型的数据

以下代码是一个简单的示例，它展示了如何实现共享对象类型的数据。

class Counter {
    private int count = 0;
    public synchronized void add(int n) {
        count += n;
    }
    public synchronized int get() {
        return count;
    }
}

public class CounterDemo {
    public static void main(String[] args) {
        Counter counter = new Counter();
        Runnable r = new Runnable() {
            @Override
            public void run() {
                counter.add(1);
                System.out.println(counter.get());
            }
        };
        Thread t1 = new Thread(r);
        Thread t2 = new Thread(r);
        t1.start();
        t2.start();
    }
}

在这个代码中，我们创建了一个计数器Counter类，count变量是用来计数的，add方法用来往计数器里增加数字，get方法用来获取计数器的值。使用synchronized关键字可以保证多个线程进行add和get操作时的线程安全，因为只有一个线程可以在同一时间对这个对象进行访问和修改。

示例2：共享集合类型的数据

以下代码是一个简单的示例，它展示了如何实现共享集合类型的数据。

class Message {
    private String text;
    public Message(String text) {
        this.text = text;
    }
    public String getText() {
        return text;
    }
}

public class MessageQueue {
    private List<Message> queue = new ArrayList<>();
    public synchronized void addMessage(Message message) {
        queue.add(message);
    }
    public synchronized Message getMessage() {
        if (queue.isEmpty()) {
            return null;
        } else {
            return queue.remove(0);
        }
    }
}

public class MessageQueueDemo {
    public static void main(String[] args) {
        MessageQueue messageQueue = new MessageQueue();
        Runnable producer = new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i < 10; i++) {
                    messageQueue.addMessage(new Message("Message" + i));
                }
            }
        };
        Runnable consumer = new Runnable() {
            @Override
            public void run() {
                while (true) {
                    Message message = messageQueue.getMessage();
                    if (message == null) {
                        break;
                    } else {
                        System.out.println("Received message: " + message.getText());
                    }
                }
            }
        };
        Thread t1 = new Thread(producer);
        Thread t2 = new Thread(consumer);
        Thread t3 = new Thread(consumer);
        t1.start();
        t2.start();
        t3.start();
    }
}

在这个代码中，我们创建了一个Message类表示消息，MessageQueue类表示消息队列，可以向队列中添加消息或获取消息，并保证多个线程对消息队列的操作线程安全。Producer线程往队列中添加10条消息，两个Consumer线程同时从队列中获取消息，直到队列为空，线程才退出。

共享基本类型的数据

Java中，基本类型的变量存储在栈内存中，每个线程都有自己的栈，因此不可能共享基本类型的数据。但是，可以使用java.util.concurrent.atomic包提供的原子类来实现多个线程之间共享基本类型的数据。原子类可以保证操作的原子性，避免线程安全问题。

示例3：共享原子变量

以下代码是一个简单的示例，它展示了如何使用原子类实现共享基本类型的数据。

public class AtomicIntegerDemo {
    private static AtomicInteger counter = new AtomicInteger(0);
    public static void main(String[] args) {
        Runnable r = new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i < 10; i++) {
                    System.out.println(counter.incrementAndGet());
                }
            }
        };
        Thread t1 = new Thread(r);
        Thread t2 = new Thread(r);
        t1.start();
        t2.start();
    }
}

在这个代码中，我们创建了一个AtomicInteger类，它可以保证对counter变量进行加1操作的原子性，从而避免了线程安全问题。两个线程同时对counter进行incrementAndGet操作，保证了并发访问时的线程安全。

以上就是Java如何实现多个线程之间共享数据的完整攻略，其中介绍了共享引用类型的数据和共享基本类型的数据的两种方式，并提供了相应的示例说明。