线程安全性分析及成员变量、实例变量、局部变量、类变量的区别及存储

执键行天涯

已于 2024-09-03 12:56:46 修改

阅读量1.7k

点赞数 38

分类专栏： JAVA进阶多线程文章标签： java jvm 开发语言

于 2024-08-27 10:27:30 首次发布

本文链接：https://blog.csdn.net/qq_39666711/article/details/141592079

版权

多线程同时被 2 个专栏收录

19 篇文章 0 订阅

订阅专栏

JAVA进阶

16 篇文章 0 订阅

订阅专栏

原文网址：线程安全性分析及成员变量、实例变量、局部变量、类变量的区别及存储
在这里插入图片描述

文章目录

一、变量分类、区别
二、成员变量和类变量（静态变量）的区别：
三、变量的内存存储
四、总结：
五、线程安全的判断实例：

在写代码时，涉及到线程安全的问题了，从而想到了JAVA中的变量是怎么区分的，怎么来确定哪些变量是线程安全的，哪些又不是安全的；
接下来，我们先一起看一下JAVA中变量的分类然后再来看哪些变量是线程安全的，哪些又不是；

一、变量分类、区别

Java的变量类型有：

成员变量类中的变量（独立于方法之外的变量）
局部变量类的方法中的变量。

而 java类的成员变量又有俩种：

静态变量（类变量）：独立于方法之外的变量，用 static 修饰。
实例变量：独立于方法之外的变量，不过没有 static 修饰。

在语法定义上的区别：

静态变量前要加static关键字，而实例变量前则不加。

在程序运行时的区别：

实例变量属于某个对象的属性，必须创建了实例对象，其中的实例变量才会被分配空间，才能使用这个实例变量。
静态变量不属于某个实例对象，而是属于类，所以也称为类变量，只要程序加载了类的字节码，不用创建任何实例对象，静态变量就会被分配空间，静态变量就可以被使用了。总之，实例变量必须创建对象后才可以通过这个对象来使用，静态变量则可以直接使用类名来引用。

public class CSDNTest {
    //类变量
    public static int judge = 0;

    //实例变量
    String str = "hello world";  

    public void method() {
        //局部变量
        int i = 0;
    }
}

一、类变量（静态变量）

类变量在类里定义，声明变量时，在变量类型前面加上 static 即可，但必须在方法之外。
类变量有默认值，数值型变量默认值是 0（或者0.0），布尔型默认值是 false，引用类型默认值是 null。
类变量可以直接在该类的方法里使用。

public class CSDNTest {
    //定义类变量
    public static double i = 2000;       

    public static void main(String[] args) {
        //直接使用类变量
        System.out.println(i);//2000
    }
}

二、实例变量

实例变量声明在一个类中，但在方法、构造方法和语句块之外。
实例变量具有默认值。数值型变量的默认值是0（或者0.0），布尔型变量的默认值是false，引用类型变量的默认值是null。
实例变量从属于对象。

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

    public static void main(String[] args) {
        //变量类型 变量名 = new 类名();
        CSDNTest test = new CSDNTest();

        System.out.println(test.age);//0
        System.out.println(test.name);//null
        //因为 age 和 name 都没有初始化，直接输出了默认值。
    }
}

三、局部变量

局部变量声明在方法、构造方法或者语句块中。
局部变量没有默认值。所以局部变量被声明后，必须经过初始化，才可以使用。
局部变量只能在自己的方法中被使用。

public class CSDNTest {
    public static void main(String[] args) {
        //局部变量
        int i = 10;
        System.out.println(i);//10
    }
}

四、常量

常量：初始化之后不会再变动的值。
常量名一般使用大写字符。

成员变量和局部变量的区别
成员变量：

      1、成员变量定义在类中，在整个类中都可以被访问。

      2、成员变量随着对象的建立而建立，随着对象的消失而消失，存在于对象所在的堆内存中。 因为堆内存是公用的，所以在这个里面的可变的变量是线程不安全的

      3、成员变量有默认初始化值。

局部变量：

      1、局部变量只定义在局部范围内，如：函数内，语句内等，只在所属的区域有效。

      2、局部变量存在于栈内存中，作用的范围结束，变量空间会自动释放。

      3、局部变量没有默认初始化值 

  在使用变量时需要遵循的原则为：就近原则

  首先在局部范围找，有就使用；接着在成员位置找。

二、成员变量和类变量（静态变量）的区别：

这里的成员变量就只标准意义上的实例变量
1、两个变量的生命周期不同

  成员变量随着对象的创建而存在，随着对象的回收而释放。
  静态变量随着类的加载而存在，随着类的消失而消失。

2、调用方式不同

  成员变量只能被对象调用。
  静态变量可以被对象调用，还可以被类名调用。

3、别名不同

  成员变量也称为实例变量。
  静态变量也称为类变量。

4、数据存储位置不同

  成员变量存储在堆内存的对象中，所以也叫对象的特有数据。
  静态变量数据存储在方法区（共享数据区）的静态区，所以也叫对象的共享数据。

成员变量所属于对象。所以也称为实例变量。
静态变量所属于类。所以也称为类变量。

成员变量存在于堆内存中。
静态变量存在于方法区中。

成员变量随着对象创建而存在。随着对象被回收而消失。
静态变量随着类的加载而存在。随着类的消失而消失。

成员变量只能被对象所调用 。
静态变量可以被对象调用，也可以被类名调用。

所以，成员变量可以称为对象的特有数据，静态变量称为对象的共享数据。

static关键字，是一个修饰符，用于修饰成员(成员变量和成员函数)。

特点：

1、想要实现对象中的共性数据的对象共享。可以将这个数据进行静态修饰。

2、被静态修饰的成员，可以直接被类名所调用。也就是说，静态的成员多了一种调用方式。类名.静态方式。

3、静态随着类的加载而加载。而且优先于对象存在。

弊端：
1、有些数据是对象特有的数据，是不可以被静态修饰的。因为那样的话，特有数据会变成对象的共享数据。这样对事物的描述就出了问题。所以，在定义静态时，必须要明确，这个数据是否是被对象所共享的。

2、静态方法只能访问静态成员，不可以访问非静态成员。

因为静态方法加载时，优先于对象存在，所以没有办法访问对象中的成员。

因为this代表对象，而静态在时，有可能没有对象，所以this无法使用。

3、静态方法中不能使用this，super关键字。

因为this代表对象，而静态在时，有可能没有对象，所以this无法使用。

什么时候定义静态成员呢？或者说：定义成员时，到底需不需要被静态修饰呢？

成员分两种：

1、成员变量。（数据共享时静态化）

该成员变量的数据是否是所有对象都一样：

如果是，那么该变量需要被静态修饰，因为是共享的数据。

如果不是，那么就说这是对象的特有数据，要存储到对象中。

2、成员函数。（方法中没有调用特有数据时就定义成静态）

如果判断成员函数是否需要被静态修饰呢？

只要参考，该函数内是否访问了对象中的特有数据：

如果有访问特有数据，那方法不能被静态修饰。

如果没有访问过特有数据，那么这个方法需要被静态修饰。

示例:实例化对象调用成员变量及成员方法的例子

public class MyClass {
    int instanceVar;  // 实例变量

    void myMethod() {
        int localVar = 10;  // 局部变量
        int sum = localVar + this.instanceVar;  // 使用实例变量的值
        System.out.println("sum = " + sum);
    }

    public static void main(String[] args) {
        MyClass obj = new MyClass();  // 实例化对象
        obj.instanceVar = 20;  // 给实例变量赋值
        obj.myMethod();  // 调用方法
    }
}

在上面的代码中

1.先实例化了一个 MyClass 对象 obj，

2.然后给实例变量 instanceVar 赋值为 20。

3.接着调用了方法 myMethod，方法内部定义了一个局部变量 localVar，

4.并使用 this.instanceVar 来访问实例变量的值进行计算。需要注意的是，这里的 this 表示当前对象，可以省略不写。执行 myMethod 方法后，会输出 sum = 30。

需要注意的是，当实例变量的名称与方法参数的名称相同时，可以使用 this 关键字来区分它们。例如：

public class MyClass {
    int value;

    public void setValue(int value) {
        this.value = value;  // 使用 this 关键字区分实例变量和方法参数
    }
}

在上面的代码中，使用 this.value 来引用实例变量，使用 value 来引用方法参数。在实例方法中使用 this 关键字可以方便地引用当前对象的实例变量、实例方法和构造方法

总结：局部变量和实例变量是 Java 中两种不同类型的变量，它们之间有以下几点区别：

定义位置不同：局部变量定义在方法、代码块或者构造函数内部，而实例变量定义在类的内部，方法的外部。
作用域不同：局部变量的作用域只限于定义它的代码块内部，一旦离开该代码块，其作用域就结束了；而实例变量的作用域则是整个对象实例。
初始化方式不同：局部变量在使用之前必须进行明确的初始化，否则编译器会报错；而实例变量在创建对象时会被自动初始化为默认值。

三、变量的内存存储

说了这么多，终于说完啦，明确了成员变量和局部变量的概念及特点之后，我们再进一步的看下这些变量在内存中是怎么存储的

一、成员变量与实例变量

存储位置：

成员变量/实例变量存储在Java堆（Heap）内存中。堆内存是Java虚拟机（JVM）用于存储所有运行时创建的对象的主要区域。当类的实例被创建时，其成员变量/实例变量作为对象的一部分被分配在堆内存中。

生命周期：

成员变量/实例变量的生命周期与对象共存亡。即，当对象被创建时，其成员变量/实例变量被初始化并存储在堆内存中；当对象被垃圾回收（GC）时，其成员变量/实例变量所占用的内存空间也随之被释放。

二、局部变量

定义：

局部变量是定义在方法内部或方法参数中的变量。它们仅在方法执行期间存在，并在方法调用结束后被销毁。

存储位置：

局部变量存储在Java栈（Stack）内存中。栈内存用于存储局部变量、方法调用等信息。每当一个方法被调用时，一个新的栈帧（Stack Frame）被创建在栈上，用于存储该方法的局部变量和参数。当方法执行完毕并返回时，其对应的栈帧被销毁，局部变量也随之消失。

生命周期：

局部变量的生命周期与方法调用共存亡。即，局部变量在方法被调用时创建，在方法执行过程中存在，并在方法执行完毕后销毁。

在这里插入图片描述

三、调用示例

程序运行就是将JAVA代码翻译成CPU指令，并且执行CPU指令的过程，方法的调用亦是如此，如下方法调用为例
int a = 7;
int[] b = fibonacci(a);
int[] c = b;

在这里插入图片描述

方法调用过程掌握较为简单，但是CPU如何获取方法的参数和返回地址呢？答案是CPU的堆栈寄存器，栈是一种线性结构就像手枪的弹夹，先进后出为栈。方法的调用就是一个压栈的过程，如下所示

存在三个方法A,B,C，其中方法A调用方法B，方法B调用方法C，每个方法入栈都会分配一片空间，这个空间称之为栈帧，栈帧中包含方法参数以及返回地址等内容，当调用方法时会创建栈帧同时入栈，调用方法完毕会从调用栈中弹出出栈，简单说就是方法和栈帧是同生共死的。

在这里插入图片描述
所以说局部变量是和栈帧同生共死的，如果想要跨越多个方法那么只能将变量创建在堆中，让方法共享

多线程调用方法为什么局部变量是安全的呢？
看下面的图就能明白：为什么局部变量线程安全，因为没有共享就没有伤害，局部变量对于每个方法的调用都是有独立的，线程与线程之前的调用栈互不干扰完全独立，这就是原因
在这里插入图片描述

四、线程封闭思想

局部变量因为不会和其它线程共享变量，所以线程安全，这种思想能够很好的解决线程安全的问题，这种思想称之为线程封闭，官方解释是仅在单线程内访问数据。

四、总结：

局部变量是线程安全的。因为局部变量是声明在方法中的变量，方法是放在JVM内存中的方法区的，为方法分配内存的时候并不会为局部变量分配内存，只有在有线程在调用方法的时候才会为局部变量分配内存，并且局部变量是分配在栈上的，栈空间是线程私有的，所以，每当有线程执行方法，都会为其在栈上分配一个局部变量的空间。所以局部变量是属于线程的，是线程安全的。

实例变量的线程安全要分两种情况来说。对于单例模式下对象的实例变量，是非线程安全的。因为在单例模式下，所有线程操作的都是同一个对象，同一个实例变量。所以是不安全的。对于普通创建的对象下的实例变量，每个线程对应一个对象，对象与对象之间的实例变量的修改互不影响，所以是线程安全的。

静态变量是属于类的，存放在方法区，所有线程操作的是同一个，是非线程安全的。

五、线程安全的判断实例：

【Java并发】变量的内存存储、线程安全分析

方法中定义的局部变量是否为线程安全的？

在这里插入图片描述

参考文章：
https://blog.csdn.net/wanderlustLee/article/details/84143963 、https://blog.csdn.net/xukuan123/article/details/130335893、https://blog.csdn.net/munangs/article/details/124401197