Java基础夯实——2.9 多线程如何共享数据

在 Java 多线程编程中，共享数据通过以下几种方式实现：

1. 使用共享对象

多个线程可以通过引用同一个对象来实现数据共享。例如：

class SharedData {private int count;public synchronized void increment() {count++;}public synchronized int getCount() {return count;}
}public class Main {public static void main(String[] args) {SharedData sharedData = new SharedData();Thread t1 = new Thread(() -> {for (int i = 0; i < 1000; i++) {sharedData.increment();}});Thread t2 = new Thread(() -> {for (int i = 0; i < 1000; i++) {sharedData.increment();}});t1.start();t2.start();try {t1.join();t2.join();} catch (InterruptedException e) {e.printStackTrace();}System.out.println("Final count: " + sharedData.getCount());}
}

解释：

• 使用 synchronized 确保线程安全。
• SharedData 是共享的对象，多个线程共同操作它。

2. 使用 volatile 关键字

volatile 可用于标记变量，使得线程对其修改对其他线程立即可见。

class SharedData {private volatile boolean flag = false;public void toggleFlag() {flag = !flag;}public boolean isFlag() {return flag;}
}public class Main {public static void main(String[] args) {SharedData sharedData = new SharedData();Thread t1 = new Thread(() -> {while (!sharedData.isFlag()) {// 等待 flag 被修改}System.out.println("Flag is now true!");});Thread t2 = new Thread(() -> {try {Thread.sleep(1000); // 模拟延迟} catch (InterruptedException e) {e.printStackTrace();}sharedData.toggleFlag();});t1.start();t2.start();}
}

解释：

• volatile 保证可见性，但不保证原子性（如递增操作需要 synchronized 或 AtomicInteger）。
• 适用于简单的状态标识共享。

3. 使用线程安全的集合

Java 提供了多种线程安全的数据结构，比如 ConcurrentHashMap、CopyOnWriteArrayList 等。

import java.util.concurrent.ConcurrentHashMap;public class Main {public static void main(String[] args) {ConcurrentHashMap<String, Integer> map = new ConcurrentHashMap<>();Runnable task = () -> {for (int i = 0; i < 10; i++) {map.put(Thread.currentThread().getName() + i, i);}};Thread t1 = new Thread(task);Thread t2 = new Thread(task);t1.start();t2.start();try {t1.join();t2.join();} catch (InterruptedException e) {e.printStackTrace();}System.out.println(map);}
}

解释：

• 无需手动加锁，线程安全由集合实现。

---

4. 使用 ThreadLocal

ThreadLocal 为每个线程提供独立的变量副本，避免共享变量的竞争。

public class Main {private static ThreadLocal<Integer> threadLocal = ThreadLocal.withInitial(() -> 0);public static void main(String[] args) {Runnable task = () -> {threadLocal.set(threadLocal.get() + 1);System.out.println(Thread.currentThread().getName() + ": " + threadLocal.get());};Thread t1 = new Thread(task);Thread t2 = new Thread(task);t1.start();t2.start();}
}

解释：

• 适合线程独立的场景。
• 不适合真正需要共享数据的情况。

5. 使用并发工具类

Java 的 java.util.concurrent 包提供了丰富的工具类来简化线程共享数据的操作，例如 CountDownLatch、CyclicBarrier 和 BlockingQueue。

示例：使用 BlockingQueue

import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.BlockingQueue;public class Main {public static void main(String[] args) {BlockingQueue<Integer> queue = new ArrayBlockingQueue<>(10);Thread producer = new Thread(() -> {try {for (int i = 0; i < 10; i++) {queue.put(i);System.out.println("Produced: " + i);}} catch (InterruptedException e) {e.printStackTrace();}});Thread consumer = new Thread(() -> {try {for (int i = 0; i < 10; i++) {int value = queue.take();System.out.println("Consumed: " + value);}} catch (InterruptedException e) {e.printStackTrace();}});producer.start();consumer.start();}
}

解释：

• 适合生产者-消费者模式。
• 队列保证线程安全。

多线程如何共享数据？

1 使用共享变量

全局变量：直接声明为类的成员变量。
静态变量：用 static 关键字修饰的变量。

2 使用并发容器

ConcurrentHashMap：支持高效的并发读写操作。
ConcurrentLinkedQueue：适用于线程安全的队列操作。

3 使用线程安全的类

AtomicInteger：原子操作的整数类。
CountDownLatch：用于同步等待多个线程完成任务。