java 线程间如何共享数据

要在Java中实现线程间的数据共享，可以使用共享对象、线程通信机制、线程安全集合、Atomic类、ThreadLocal等方式。 共享对象是一种常见的方法，通过将数据放置在一个对象中，并确保该对象被多个线程访问。接下来，我们将详细讨论这些方法。

一、共享对象

共享对象是通过将数据放置在一个对象中，然后在多个线程中引用该对象来实现数据共享。这种方法通常要求对共享对象进行同步，以避免线程间的竞争条件。

1.1、使用synchronized关键字

使用synchronized关键字可以确保在同一时刻只有一个线程可以访问共享对象的某个部分。下面是一个简单的示例：

public class SharedObject {
    private int data;
    public synchronized void setData(int data) {
        this.data = data;
    }
    public synchronized int getData() {
        return data;
    }
}
public class WorkerThread extends Thread {
    private SharedObject sharedObject;
    public WorkerThread(SharedObject sharedObject) {
        this.sharedObject = sharedObject;
    }
    public void run() {
        sharedObject.setData(sharedObject.getData() + 1);
    }
}
public class Main {
    public static void main(String[] args) throws InterruptedException {
        SharedObject sharedObject = new SharedObject();
        Thread t1 = new WorkerThread(sharedObject);
        Thread t2 = new WorkerThread(sharedObject);
        t1.start();
        t2.start();
        t1.join();
        t2.join();
        System.out.println("Final Data: " + sharedObject.getData());
    }
}

在上述示例中，SharedObject类的setData和getData方法使用了synchronized关键字，确保在同一时间只有一个线程可以访问这些方法，从而避免了竞争条件。

1.2、使用ReentrantLock

ReentrantLock提供了比synchronized更多的灵活性和功能，比如尝试锁定、定时锁定等。以下是一个使用ReentrantLock的示例：

import java.util.concurrent.locks.ReentrantLock;
public class SharedObject {
    private int data;
    private final ReentrantLock lock = new ReentrantLock();
    public void setData(int data) {
        lock.lock();
        try {
            this.data = data;
        } finally {
            lock.unlock();
        }
    }
    public int getData() {
        lock.lock();
        try {
            return data;
        } finally {
            lock.unlock();
        }
    }
}
public class WorkerThread extends Thread {
    private SharedObject sharedObject;
    public WorkerThread(SharedObject sharedObject) {
        this.sharedObject = sharedObject;
    }
    public void run() {
        sharedObject.setData(sharedObject.getData() + 1);
    }
}
public class Main {
    public static void main(String[] args) throws InterruptedException {
        SharedObject sharedObject = new SharedObject();
        Thread t1 = new WorkerThread(sharedObject);
        Thread t2 = new WorkerThread(sharedObject);
        t1.start();
        t2.start();
        t1.join();
        t2.join();
        System.out.println("Final Data: " + sharedObject.getData());
    }
}

二、线程通信机制

线程通信机制如wait、notify和notifyAll可以用于协调线程间的操作，确保线程在适当的时机访问共享数据。

2.1、使用wait和notify

wait和notify方法通常与synchronized结合使用，以确保线程在访问共享资源时的正确性。以下是一个简单的示例：

public class SharedObject {
    private int data;
    private boolean available = false;
    public synchronized void setData(int data) {
        while (available) {
            try {
                wait();
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
        }
        this.data = data;
        available = true;
        notifyAll();
    }
    public synchronized int getData() {
        while (!available) {
            try {
                wait();
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
        }
        available = false;
        notifyAll();
        return data;
    }
}
public class ProducerThread extends Thread {
    private SharedObject sharedObject;
    public ProducerThread(SharedObject sharedObject) {
        this.sharedObject = sharedObject;
    }
    public void run() {
        for (int i = 0; i < 10; i++) {
            sharedObject.setData(i);
        }
    }
}
public class ConsumerThread extends Thread {
    private SharedObject sharedObject;
    public ConsumerThread(SharedObject sharedObject) {
        this.sharedObject = sharedObject;
    }
    public void run() {
        for (int i = 0; i < 10; i++) {
            System.out.println("Data: " + sharedObject.getData());
        }
    }
}
public class Main {
    public static void main(String[] args) throws InterruptedException {
        SharedObject sharedObject = new SharedObject();
        Thread producer = new ProducerThread(sharedObject);
        Thread consumer = new ConsumerThread(sharedObject);
        producer.start();
        consumer.start();
        producer.join();
        consumer.join();
    }
}

在这个示例中，SharedObject类的setData和getData方法使用了wait和notifyAll来协调生产者线程和消费者线程的操作。

三、线程安全集合

Java提供了一些线程安全的集合类，如ConcurrentHashMap、CopyOnWriteArrayList和BlockingQueue，这些集合类可以在多个线程之间共享数据而无需显式同步。

3.1、使用ConcurrentHashMap

ConcurrentHashMap是一种线程安全的哈希表，适用于高并发场景。以下是一个简单的示例：

import java.util.concurrent.ConcurrentHashMap;
public class WorkerThread extends Thread {
    private ConcurrentHashMap<String, Integer> map;
    public WorkerThread(ConcurrentHashMap<String, Integer> map) {
        this.map = map;
    }
    public void run() {
        for (int i = 0; i < 10; i++) {
            map.put(Thread.currentThread().getName() + i, i);
        }
    }
}
public class Main {
    public static void main(String[] args) throws InterruptedException {
        ConcurrentHashMap<String, Integer> map = new ConcurrentHashMap<>();
        Thread t1 = new WorkerThread(map);
        Thread t2 = new WorkerThread(map);
        t1.start();
        t2.start();
        t1.join();
        t2.join();
        System.out.println("Map: " + map);
    }
}

3.2、使用BlockingQueue

BlockingQueue是一种线程安全的队列，适用于生产者-消费者模型。以下是一个简单的示例：

import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.BlockingQueue;
public class ProducerThread extends Thread {
    private BlockingQueue<Integer> queue;
    public ProducerThread(BlockingQueue<Integer> queue) {
        this.queue = queue;
    }
    public void run() {
        try {
            for (int i = 0; i < 10; i++) {
                queue.put(i);
            }
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }
    }
}
public class ConsumerThread extends Thread {
    private BlockingQueue<Integer> queue;
    public ConsumerThread(BlockingQueue<Integer> queue) {
        this.queue = queue;
    }
    public void run() {
        try {
            for (int i = 0; i < 10; i++) {
                System.out.println("Data: " + queue.take());
            }
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }
    }
}
public class Main {
    public static void main(String[] args) throws InterruptedException {
        BlockingQueue<Integer> queue = new ArrayBlockingQueue<>(10);
        Thread producer = new ProducerThread(queue);
        Thread consumer = new ConsumerThread(queue);
        producer.start();
        consumer.start();
        producer.join();
        consumer.join();
    }
}

四、Atomic类

Java的java.util.concurrent.atomic包提供了一些原子操作类，如AtomicInteger、AtomicLong和AtomicReference，这些类可以实现线程安全的操作，而无需显式同步。

4.1、使用AtomicInteger

AtomicInteger提供了一些原子操作方法，如incrementAndGet、decrementAndGet等，以下是一个简单的示例：

import java.util.concurrent.atomic.AtomicInteger;
public class WorkerThread extends Thread {
    private AtomicInteger counter;
    public WorkerThread(AtomicInteger counter) {
        this.counter = counter;
    }
    public void run() {
        for (int i = 0; i < 10; i++) {
            System.out.println("Counter: " + counter.incrementAndGet());
        }
    }
}
public class Main {
    public static void main(String[] args) throws InterruptedException {
        AtomicInteger counter = new AtomicInteger(0);
        Thread t1 = new WorkerThread(counter);
        Thread t2 = new WorkerThread(counter);
        t1.start();
        t2.start();
        t1.join();
        t2.join();
    }
}

五、ThreadLocal

ThreadLocal为每个线程提供了独立的变量副本，适用于需要为每个线程维护独立状态的场景。

5.1、使用ThreadLocal

以下是一个使用ThreadLocal的简单示例：

public class WorkerThread extends Thread {
    private static final ThreadLocal<Integer> threadLocal = ThreadLocal.withInitial(() -> 0);
    public void run() {
        for (int i = 0; i < 10; i++) {
            threadLocal.set(threadLocal.get() + 1);
            System.out.println("Thread " + Thread.currentThread().getName() + ": " + threadLocal.get());
        }
    }
}
public class Main {
    public static void main(String[] args) throws InterruptedException {
        Thread t1 = new WorkerThread();
        Thread t2 = new WorkerThread();
        t1.start();
        t2.start();
        t1.join();
        t2.join();
    }
}

在上述示例中，ThreadLocal为每个线程提供了一个独立的Integer变量副本，因此每个线程都可以独立地操作其副本。

总结

在Java中实现线程间的数据共享有多种方法，每种方法都有其适用的场景和优缺点。共享对象和同步机制适用于简单的共享数据场景，但需要小心处理同步问题；线程通信机制如wait和notify适用于生产者-消费者模型；线程安全集合提供了便捷的并发数据结构；Atomic类提供了高效的原子操作；ThreadLocal适用于为每个线程维护独立状态。根据具体需求选择合适的方法，可以有效实现线程间的数据共享。