多线程下环境中的类变量使用

Time丶陌若

已于 2023-05-24 08:37:45 修改

阅读量858

点赞数

分类专栏：爪哇文章标签： java

于 2023-05-23 22:58:56 首次发布

本文链接：https://blog.csdn.net/qq_43587405/article/details/130835958

版权

爪哇专栏收录该内容

1 篇文章 0 订阅

订阅专栏

静态变量

当修改Java中的静态变量时，可能会遇到以下问题：
静态变量是属于整个类的，而不是类的实例。如果多个线程同时修改静态变量的值，可能导致竞态条件和不一致的结果。

1.多线程竞争问题：如果多个线程同时修改静态变量的值，可能导致竞态条件和不一致的结果。

public class StaticVariableExample {

    private static int counter = 0;

    public static void main(String[] args) {
        Thread thread1 = new Thread(() -> {
            for (int i = 0; i < 1000; i++) {
                counter++; // 线程1增加counter的值
            }
        });

        Thread thread2 = new Thread(() -> {
            for (int i = 0; i < 1000; i++) {
                counter--; // 线程2减少counter的值
            }
        });

        thread1.start();
        thread2.start();

        try {
            thread1.join();
            thread2.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        System.out.println("counter的值：" + counter);
    }
}

在上面的例子中，两个线程同时修改静态变量counter的值，一个增加，一个减少。由于两个线程的操作没有同步控制，最终的结果是不确定的，可能每次运行时都会得到不同的结果。

2.可见性问题：在多线程环境下，一个线程修改了静态变量的值，其他线程可能无法立即看到这个变化。

public class StaticVariableExample {

    private static boolean flag = false;

    public static void main(String[] args) {
        Thread thread1 = new Thread(() -> {
            flag = true; // 线程1修改flag的值
        });

        Thread thread2 = new Thread(() -> {
            while (!flag) {
                // 线程2不断循环等待，直到flag的值变为true
            }
            System.out.println("flag的值已经变为true");
        });

        thread1.start();
        thread2.start();

        try {
            thread1.join();
            thread2.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

在上述代码中，线程1修改静态变量flag的值为true，而线程2在循环等待中检查flag的值。如果没有适当的同步机制，例如使用volatile关键字或同步块/方法，线程2可能会陷入无限循环，因为它无法看到线程1对flag的修改。

静态不可变变量

在Java中，静态不可变变量是指在整个类中共享且不可修改的常量，它们使用static final关键字进行声明。静态不可变变量具有以下特点：

1.共享性：静态不可变变量是类级别的，所有实例和方法都可以访问它们。它们在整个类中共享相同的值，无论创建多少个类的实例，它们的值都不会改变。

2.不可修改性：一旦静态不可变变量被初始化赋值，其值就不能被修改。这使得它们成为表示常量值的良好选择。

注意：当变量类型不是基本数据类型时；如：

private static final Map<String, Integer> MAP = new HashMap<>();

尽管static final修饰的变量本身是不可变的，但如果Map对象本身是可变的，则可能仍然可以修改其内容。这意味着虽然无法修改MAP变量引用的Map对象，但可以通过该对象对Map中的内容进行更改。

public class StaticFinalMapExample {
    private static final Map<String, Integer> MAP = new HashMap<>();

    public static void main(String[] args) {
    	// MAP = new HashMap<>();  // 编译错误，无法修改不可变的Map变量
        MAP.put("key", 10); // 编译通过，将键值对添加到Map中
        System.out.println(MAP); // 输出: {key=10}
        
        MAP.put("key", 20); // 编译通过，修改Map中键对应的值
        System.out.println(MAP); // 输出: {key=20}
    }
}

在多线程环境中可能会面临以下问题：

1.可见性问题：在多线程环境下，一个线程修改了static final Map的内容，其他线程可能无法立即看到这个变化。这是因为没有适当的同步机制来保证对Map的修改在所有线程中可见。

public class StaticFinalMapExample {
    private static final Map<String, Integer> MAP = new HashMap<>();

    public static void main(String[] args) {
        MAP.put("key", 10); // 初始化静态Map
        
        Thread thread1 = new Thread(() -> {
            MAP.put("key", 20); // 线程1修改Map的值
        });

        Thread thread2 = new Thread(() -> {
            int value = MAP.get("key"); // 线程2读取Map的值
            System.out.println("值：" + value); // 可能输出旧的值10，而不是修改后的值20
        });

        thread1.start();
        thread2.start();
    }
}

在上述代码中，线程1修改了MAP的值，而线程2在读取MAP的值时可能无法立即看到这个变化。这可能导致线程2读取到旧的值10，而不是修改后的值20。

2.并发修改问题：如果多个线程同时尝试修改static final Map的内容，可能会导致并发修改异常（ConcurrentModificationException）或导致数据不一致。

public class StaticFinalMapExample {
    private static final Map<String, Integer> MAP = new HashMap<>();

    public static void main(String[] args) {
        MAP.put("key", 10); // 初始化静态Map
        
        Thread thread1 = new Thread(() -> {
            for (int i = 0; i < 1000; i++) {
                MAP.put("key", i); // 线程1修改Map的值
            }
        });

        Thread thread2 = new Thread(() -> {
            int value = MAP.get("key"); // 线程2读取Map的值
            System.out.println("值：" + value); // 输出可能不确定，可能抛出ConcurrentModificationException（并发修改异常）异常
        });

        thread1.start();
        thread2.start();
    }
}

实例变量

实例变量是在类中声明的变量，其值与类的每个实例相关联。每个类的实例都有自己独立的实例变量副本，它们的值可以在对象的生命周期中发生变化。实例变量没有使用static关键字修饰，因此它们属于对象级别的变量。

public class InstanceVariableExample {
    private String name; // 实例变量
    private int age; // 实例变量

    public void setName(String name) {
        this.name = name; // 设置实例变量name的值
    }

    public void setAge(int age) {
        this.age = age; // 设置实例变量age的值
    }

    public void displayInfo() {
        System.out.println("Name: " + name);
        System.out.println("Age: " + age);
    }

    public static void main(String[] args) {
        InstanceVariableExample obj1 = new InstanceVariableExample();
        obj1.setName("John");
        obj1.setAge(25);
        obj1.displayInfo();

        InstanceVariableExample obj2 = new InstanceVariableExample();
        obj2.setName("Jane");
        obj2.setAge(30);
        obj2.displayInfo();
    }
}

当 Java 实例变量被修改时，可能会引发以下问题：

不一致的状态：如果一个实例变量在多个方法中被修改，但没有进行适当的同步或控制，可能会导致实例变量的值在不同的地方出现不一致的情况。这可能导致程序行为的不确定性或错误的结果。
线程安全性问题：如果多个线程同时修改同一个实例变量，并且没有进行适当的同步，可能会引发线程安全性问题，如竞态条件（Race Condition）、数据竞争（Data Race）等。这可能导致数据损坏、死锁、无限循环等问题。
并发访问问题：如果一个实例变量被多个线程同时访问，而没有进行适当的同步或控制，可能会导致并发访问问题。这可能导致数据不一致或意外的结果。
可维护性问题：当实例变量被频繁地修改时，代码可能会变得难以理解和维护。过多的修改可能增加代码的复杂性，使程序难以调试和修改。

为了避免这些问题，可以采取以下措施：

将实例变量声明为私有（private），并提供公共（public）的访问方法（getter 和 setter）来控制对实例变量的访问。
在多线程环境中，使用同步机制（如 synchronized 关键字、锁对象等）来保证对实例变量的安全访问。
尽量减少对实例变量的直接修改，推荐使用不可变（immutable）对象或方法来实现数据的修改和操作。
根据需要进行适当的封装和抽象，将相关的状态和行为组织在一起，提高代码的可读性和可维护性。

总之，合理地使用实例变量，并进行适当的访问控制和同步机制，可以避免潜在的问题，并提高程序的健壮性和可靠性。

反例：展示了在没有适当同步机制的情况下修改实例变量可能导致的问题：问题在于，当多个线程同时调用 increment() 方法时，由于没有同步机制来保护 count 的访问，可能会发生竞态条件（Race Condition）：由于 increment() 方法没有进行同步，多个线程可能会同时读取和修改 count 变量，导致计数不准确。输出的结果可能不是期望的 2000，而是一个小于 2000 的值。

public class Counter {
    private int count;

    public int getCount() {
        return count;
    }

    public void increment() {
        count++;
    }
}



public class test1 {
    public static void main(String[] args) throws InterruptedException {
    // 创建实例
        Counter counter = new Counter();

// 线程1
        Runnable runnable1 = () -> {
            for (int i = 0; i < 1000; i++) {
                counter.increment();
            }
        };

// 线程2
        Runnable runnable2 = () -> {
            for (int i = 0; i < 1000; i++) {
                counter.increment();
            }
        };

        Thread thread1 = new Thread(runnable1);
        Thread thread2 = new Thread(runnable2);

        thread1.start();
        thread2.start();

    // 等待两个线程执行完毕
        thread1.join();
        thread2.join();

        System.out.println(counter.getCount()); // 可能输出的结果不是 2000

    }
}

Time丶陌若

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
多线程下环境中的类变量使用

展示了在没有适当同步机制的情况下修改实例变量可能导致的问题：问题在于，当多个线程同时调用 increment() 方法时，由于没有同步机制来保护 count 的访问，可能会发生竞态条件（Race Condition）：由于 increment() 方法没有进行同步，多个线程可能会同时读取和修改 count 变量，导致计数不准确。不一致的状态：如果一个实例变量在多个方法中被修改，但没有进行适当的同步或控制，可能会导致实例变量的值在不同的地方出现不一致的情况。这可能导致程序行为的不确定性或错误的结果。
复制链接

扫一扫