78-java 多线程如何共享数据

weixin_41775999

已于 2024-09-13 11:04:48 修改

阅读量1k

点赞数 6

文章标签： java 开发语言

于 2024-09-10 15:03:45 首次发布

本文链接：https://blog.csdn.net/weixin_41775999/article/details/142099297

版权

在Java中，多个线程可以通过共享对象来共享数据。这可以通过以下几种方式实现：

实例变量共享：如果多个线程访问同一个对象的实例变量，那么这些线程将共享这些实例变量。

public class SharedData {
    public int sharedData = 0;
 
    public void increase() {
        sharedData++;
    }
}
 
public class ThreadExample implements Runnable {
    private SharedData sharedData;
 
    public ThreadExample(SharedData sharedData) {
        this.sharedData = sharedData;
    }
 
    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            sharedData.increase();
        }
    }
}
 
public class Main {
    public static void main(String[] args) {
        SharedData sharedData = new SharedData();
        ThreadExample example = new ThreadExample(sharedData);
 
        Thread t1 = new Thread(example);
        Thread t2 = new Thread(example);
 
        t1.start();
        t2.start();
 
        try {
            t1.join();
            t2.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
 
        System.out.println("SharedData: " + sharedData.sharedData);
    }
}

使用volatile关键字：如果你希望确保所有线程看到共享变量的最新值，并且不会缓存这个变量的旧值，你可以使用volatile关键字。
```
public class SharedData {
    public volatile int sharedData = 0;
 
    public void increase() {
        sharedData++;
    }
}
```

使用synchronized关键字：当你需要在多个线程之间同步访问共享数据时，可以使用synchronized关键字。

public class SharedData {
    public int sharedData = 0;
 
    public synchronized void increase() {
        sharedData++;
    }
}

使用ReentrantLock：ReentrantLock提供了比synchronized更广泛的锁定操作，可以更灵活地控制同步。

import java.util.concurrent.locks.ReentrantLock;
 
public class SharedData {
    public int sharedData = 0;
    private final ReentrantLock lock = new ReentrantLock();
 
    public void increase() {
        lock.lock();
        try {
            sharedData++;
        } finally {
            lock.unlock();
        }
    }
}

使用原子变量：java.util.concurrent.atomic包中的原子变量类提供了一种方式来进行无锁的、线程安全的操作。

import java.util.concurrent.atomic.AtomicInteger;
 
public class SharedData {
    public AtomicInteger sharedData = new AtomicInteger(0);
 
    public void increase() {
        sharedData.incrementAndGet();
    }
}

使用线程安全集合：java.util.concurrent包中提供了一些线程安全的集合类，可以用来存储共享数据。

import java.util.concurrent.ConcurrentHashMap;
 
public class SharedData {
    public ConcurrentHashMap<String, Integer> sharedData = new ConcurrentHashMap<>();
 
    public void increase(String key) {
        sharedData.compute(key, (k, v) -> v == null ? 1 : v + 1);
    }
}

使用ThreadLocal：ThreadLocal可以为每个线程提供一个独立的变量副本，从而避免共享数据。
```
public class ThreadLocalExample {
    public static final ThreadLocal<Integer> localData =
```