Java多线程数据共享的奇妙世界

2023-10-31 12:53:53

线程范围的共享变量

在Java中，线程范围的共享变量是指在多个线程之间共享的变量。这些变量通常是静态变量或成员变量，并且可以在线程的整个生命周期内访问。例如，以下代码定义了一个名为“data”的静态变量：

public class Data {

    private static int data = 0;

    public static void main(String[] args) {

        // 创建两个线程，每个线程都将增加“data”变量的值
        Thread thread1 = new Thread(() -> {
            for (int i = 0; i < 10000; i++) {
                data++;
            }
        });

        Thread thread2 = new Thread(() -> {
            for (int i = 0; i < 10000; i++) {
                data++;
            }
        });

        // 启动两个线程
        thread1.start();
        thread2.start();

        // 等待两个线程执行完成
        try {
            thread1.join();
            thread2.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        // 打印“data”变量的值
        System.out.println("Final value of data: " + data);
    }
}

在上面的代码中，我们创建了两个线程，每个线程都将“data”变量的值增加10000次。当两个线程执行完成后，我们打印“data”变量的值，并观察到它的值是20000。这表明两个线程共享了“data”变量，并且它们能够同时访问和修改它。

多个业务模块针对同一个静态变量的操作

在实际开发中，我们经常会遇到多个业务模块需要针对同一个静态变量进行操作的情况。例如，在电商系统中，我们可能需要维护一个名为“库存量”的静态变量，以便各个模块都可以随时获取库存信息。为了保证在不同线程中各个模块操作的是自身对应的变量对象，我们可以使用以下方法：

使用线程本地变量： 线程本地变量是指每个线程都有自己的独立副本，并且不会被其他线程访问的变量。我们可以使用ThreadLocal类来创建线程本地变量。例如：

public class Data {

    private static ThreadLocal<Integer> data = new ThreadLocal<>();

    public static void main(String[] args) {

        // 创建两个线程，每个线程都将增加“data”变量的值
        Thread thread1 = new Thread(() -> {
            for (int i = 0; i < 10000; i++) {
                data.set(data.get() + 1);
            }
        });

        Thread thread2 = new Thread(() -> {
            for (int i = 0; i < 10000; i++) {
                data.set(data.get() + 1);
            }
        });

        // 启动两个线程
        thread1.start();
        thread2.start();

        // 等待两个线程执行完成
        try {
            thread1.join();
            thread2.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        // 打印“data”变量的值
        System.out.println("Final value of data: " + data.get());
    }
}

在上面的代码中，我们使用ThreadLocal类创建了一个名为“data”的线程本地变量。每个线程都会拥有自己的“data”变量副本，并且不会被其他线程访问。因此，当两个线程同时执行时，它们不会相互影响，并且最终输出的“data”变量的值将是20000。

使用同步机制： 同步机制是指通过锁来控制对共享资源的访问，从而防止多个线程同时访问和修改共享资源。我们可以使用synchronized或ReentrantLock类来实现同步机制。例如：

public class Data {

    private static int data = 0;

    public static void main(String[] args) {

        // 创建两个线程，每个线程都将增加“data”变量的值
        Thread thread1 = new Thread(() -> {
            for (int i = 0; i < 10000; i++) {
                synchronized (Data.class) {
                    data++;
                }
            }
        });

        Thread thread2 = new Thread(() -> {
            for (int i = 0; i < 10000; i++) {
                synchronized (Data.class) {
                    data++;
                }
            }
        });

        // 启动两个线程
        thread1.start();
        thread2.start();

        // 等待两个线程执行完成
        try {
            thread1.join();
            thread2.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        // 打印“data”变量的值
        System.out.println("Final value of data: " + data);
    }
}