网站链接: element-ui dtcms
当前位置: 首页 > 技术博文  > 技术博文

JVM_05)虚拟机栈

2021/5/4 4:55:09 人评论

虚拟机栈 1 虚拟机栈概述 1.1 背景 由于跨平台性的设计,Java 的指令都是根据栈来设计的。不同平台 CPU 架构不同,所以不能设计为基于寄存器的。 栈的优点是跨平台,指令集小,编译器容易实现,缺点是性能下降&#xf…

虚拟机栈

1 虚拟机栈概述

1.1 背景

由于跨平台性的设计,Java 的指令都是根据栈来设计的。不同平台 CPU 架构不同,所以不能设计为基于寄存器的。

栈的优点是跨平台,指令集小,编译器容易实现,缺点是性能下降,实现同样的功能需要更多的指令。

有不少 Java 开发人员一提到 Java 内存结构,就会非常粗粒度地将 JVM 中的内存区理解为仅有 Java 堆(heap)和 Java 栈(stack)?为什么?

首先栈是运行时的单位,而堆是存储的单位

  • 栈解决程序的运行问题,即程序如何执行,或者说如何处理数据。
  • 堆解决的是数据存储的问题,即数据怎么放,放哪里

image-20200705163928652

1.2 虚拟机栈的基本内容

1.2.1 虚拟机栈是什么?

Java 虚拟机栈(Java Virtual Machine Stack),早期也叫 Java 栈。每个线程在创建时都会创建一个虚拟机栈,其内部保存一个个的栈帧(Stack Frame),对应着一次次的 Java 方法调用。

  • 栈是线程私有的

1.2.2 生命周期

生命周期和线程一致。

1.2.3 作用

主管 Java 程序的运行,它保存方法的局部变量、部分结果,并参与方法的调用和返回。

局部变量,它是相比于成员变量来说的(或属性)

基本数据类型变量 VS 引用类型变量(类、数组、接口)

image-20210307104124193

1.2.4 栈的特点

栈是一种快速有效的分配存储方式,访问速度仅次于程序计数器。JVM 直接对 Java 栈的操作只有两个:

  • 每个方法执行,伴随着进栈(入栈、压栈)
  • 执行结束后的出栈工作

对于栈来说不存在垃圾回收问题(栈存在溢出的情况)

image-20210307104335824

1.2.5 栈中可能出现的异常

Java 虚拟机规范允许 Java 栈的大小是动态的或者是固定不变的

如果采用固定大小的 Java 虚拟机栈,那每一个线程的 Java 虚拟机栈容量可以在线程创建的时候独立选定。如果线程请求分配的栈容量超过 Java 虚拟机栈允许的最大容量,Java 虚拟机将会抛出一个 StackOverflowError 异常。

如果 Java 虚拟机栈可以动态扩展,并且在尝试扩展的时候无法申请到足够的内存,或者在创建新的线程时没有足够的内存去创建对应的虚拟机栈,那 Java 虚拟机将会抛出一个 OutOfMemoryError 异常。

/**
 * 演示栈溢出异常
 *
 * @author zzn
 */
public class StackErrorTest {
    private static int count = 1;

    public static void main(String[] args) {
        System.out.println(count++);
        main(args);
    }
}

当栈深度达到 9803 的时候,就出现栈内存空间不足

1.2.6 设置栈内存大小

我们可以使用参数 -Xss 选项来设置线程的最大栈空间,栈的大小直接决定了函数调用的最大可达深度

-Xss1m
-Xss1k

2 栈的存储单位

2.1 栈中存储什么?

每个线程都有自己的栈,栈中的数据都是以栈帧(Stack Frame)的格式存在。

在这个线程上正在执行的每个方法都各自对应一个栈颜(Stack Frame)。

栈帧是一个内存区块,是一个数据集,维系着方法执行过程中的各种数据信息。

2.2 栈运行原理

JVM 直接对 Java 栈的操作只有两个,就是对栈帧的压栈出栈,遵循“先进后出”/“后进先出”原则。

在一条活动线程中,一个时间点上,只会有一个活动的栈帧。即只有当前正在执行的方法的栈帧(栈顶栈帧)是有效的,这个栈帧被称为当前栈帧(Current Frame),与当前栈帧相对应的方法就是当前方法(Current Method),定义这个方法的类就是当前类(Current Class)。

执行引擎运行的所有字节码指令只针对当前栈帧进行操作。

如果在该方法中调用了其他方法,对应的新的栈帧会被创建出来,放在栈的顶端,成为新的当前帧。

image-20200705203142545

3.3 示例代码

/**
 * 栈帧
 *
 * @author zzn
 */
public class StackFrameTest {
    public static void main(String[] args) {
        method01();
    }

    private static int method01() {
        System.out.println("方法1的开始");
        int i = method02();
        System.out.println("方法1的结束");
        return i;
    }

    private static int method02() {
        System.out.println("方法2的开始");
        int i = method03();
        System.out.println("方法2的结束");
        return i;
    }

    private static int method03() {
        System.out.println("方法3的开始");
        int i = 30;
        System.out.println("方法3的结束");
        return i;
    }
}

运行结果为:

方法1的开始
方法2的开始
方法3的开始
方法3的结束
方法2的结束
方法1的结束

满足栈先进后出的概念

3.4 栈运行原理

不同线程中所包含的栈帧是不允许存在相互引用的,即不可能在一个栈帧之中引用另外一个线程的栈帧。

如果当前方法调用了其他方法,方法返回之际,当前栈帧会传回此方法的执行结果给前一个栈帧,接着,虚拟机会丢弃当前栈帧,使得前一个栈帧重新成为当前栈帧。

Java方法有两种返回函数的方式,一种是正常的函数返回,使用 return 指令;另外一种是抛出异常。不管使用哪种方式,都会导致栈帧被弹出。

3.5 栈帧的内部结构

每个栈帧中存储着:

  • 局部变量表(Local Variables)
  • 操作数栈(operand Stack)(或表达式栈)
  • 动态链接(DynamicLinking)(或指向运行时常量池的方法引用)
  • 方法返回地址(Return Address)(或方法正常退出或者异常退出的定义)
  • 一些附加信息

image-20210307225522823

每个线程下的栈都是私有的,因此每个线程都有自己各自的栈,并且每个栈里面都有很多栈帧,栈帧的大小主要由局部变量表操作数栈决定的

image-20200705205443993

3 局部变量表

3.1 什么是局部变量表?

局部变量表:Local Variables,被称之为局部变量数组或本地变量表

定义为一个数字数组,主要用于存储方法参数和定义在方法体内的局部变量这些数据类型包括各类基本数据类型、对象引用(reference),以及returnAddress类型。

由于局部变量表是建立在线程的栈上,是线程的私有数据,因此不存在数据安全问题

局部变量表所需的容量大小是在编译期确定下来的,并保存在方法的Code属性的 maximum local variables 数据项中。在方法运行期间是不会改变局部变量表的大小的。

**方法嵌套调用的次数由栈的大小决定。**一般来说,栈越大,方法嵌套调用次数越多。对一个函数而言,它的参数和局部变量越多,使得局部变量表膨胀,它的栈帧就越大,以满足方法调用所需传递的信息增大的需求。进而函数调用就会占用更多的栈空间,导致其嵌套调用次数就会减少。

局部变量表中的变量只在当前方法调用中有效。在方法执行时,虚拟机通过使用局部变量表完成参数值到参数变量列表的传递过程。当方法调用结束后,随着方法栈帧的销毁,局部变量表也会随之销毁。

3.2 什么是 Slot?

参数值的存放总是在局部变量数组的 index0 开始,到数组长度 -1 的索引结束。

局部变量表,最基本的存储单元是 Slot(变量槽)

局部变量表中存放编译期可知的各种基本数据类型(8种),引用类型(reference),returnAddress 类型的变量。

在局部变量表里,32位以内的类型只占用一个 Slot(包括 returnAddress 类型),64位的类型(long 和 double)占用两个 Slot。

byte、short、char 在存储前被转换为 int,boolean 也被转换为 int,0 表示 false,非 0 表示 true。

long 和 double 则占据两 个 Slot。

JVM 会为局部变量表中的每一个 Slot 都分配一个访问索引,通过这个索引即可成功访问到局部变量表中指定的局部变量值

当一个实例方法被调用的时候,它的方法参数和方法体内部定义的局部变量将会按照顺序被复制到局部变量表中的每一个 Slot 上

如果需要访问局部变量表中一个 64bit 的局部变量值时,只需要使用前一个索引即可。(比如:访问 long 或 double 类型变量)

如果当前帧是由构造方法或者实例方法创建的,那么该对象引用 this 将会存放在 index 为 0 的 Slot 处,其余的参数按照参数表顺序继续排列。

image-20210315163557200

3.3 Slot 示例

/**
 * 局部变量表
 *
 * @author zzn
 */
public class LocalVariablesTest {

    private int count;


    public LocalVariablesTest() {
        this.count = 1;
    }

    public static void main(String[] args) {
        LocalVariablesTest test = new LocalVariablesTest();
        System.out.println(test.count);
    }


    public static void testStatic() {
        LocalVariablesTest test = new LocalVariablesTest();
        Date date = new Date();
        int count = 10;
        System.out.println(count);
        // 报错,因为this变量不存在当前方法的局部变量表中
        // System.out.println(this.count);
    }

    public void test() {
        int a = 0;
        for (int i = 0; i < 2; i++) {
            i = i + 1;
        }
        // 变量 c 使用之前已经销毁的变量 b 占据的 slot 的位置
        int c = a + 1;
    }

}

3.4 局部变量和静态变量

变量的分类:

  • 按数据类型分:基本数据类型、引用数据类型
  • 按类中声明的位置分:成员变量(类变量,实例变量)、局部变量
    • 类变量:linking 的 prepare 阶段,给类变量默认赋值 ----> initial 阶段:给类变量显示赋值即静态代码块
    • 实例变量:随着对象创建,会在堆空间中分配实例变量空间,并进行默认赋值
    • 局部变量:在使用前必须进行显式赋值,不然编译不通过。

参数表分配完毕之后,再根据方法体内定义的变量的顺序和作用域分配。

我们知道类变量表有两次初始化的机会,第一次是在“准备阶段”,执行系统初始化,对类变量设置零值,另一次则是在“初始化”阶段,赋予程序员在代码中定义的初始值。

和类变量初始化不同的是,局部变量表不存在系统初始化的过程,这意味着一旦定义了局部变量则必须人为的初始化,否则无法使用。

public void test() {
    int i;
    // 报错,没有对变量进行初始化
    // System.out.println(i);
}

3.5 补充说明

在栈帧中,与性能调优关系最为密切的部分就是前面提到的局部变量表。在方法执行时,虚拟机使用局部变量表完成方法的传递。

局部变量表中的变量也是重要的垃圾回收根节点,只要被局部变量表中直接或间接引用的对象都不会被回收。

4 操作数栈

4.1 概念

操作数栈:Operand Stack

每一个独立的栈帧除了包含局部变量表以外,还包含一个后进先出(Last - In - First -Out)的 操作数栈,也可以称之为 表达式栈(Expression Stack)

操作数栈,在方法执行过程中,根据字节码指令,往栈中写入数据或提取数据,即入栈(push)和 出栈(pop)

  • 某些字节码指令将值压入操作数栈,其余的字节码指令将操作数取出栈。使用它们后再把结果压入栈
  • 比如:执行复制、交换、求和等操作

image-20200706090618332

4.2 代码举例

public void testAddOperation() {
    // byte、short、char、boolean 内部都是使用int型来进行保存的
    byte i = 15;
    int j = 8;
    int k = i + j;
}

字节码指令信息

public void testAddOperation();
    Code:
       0: bipush        15
       2: istore_1
       3: bipush        8
       5: istore_2
       6: iload_1
       7: iload_2
       8: iadd
       9: istore_3
      10: return

操作数栈,主要用于保存计算过程的中间结果,同时作为计算过程中变量临时的存储空间。

操作数栈就是 JVM 执行引擎的一个工作区,当一个方法刚开始执行的时候,一个新的栈帧也会随之被创建出来,这个方法的操作数栈是空的。

这个时候数组是有长度的,因为数组一旦创建,那么就是不可变的

每一个操作数栈都会拥有一个明确的栈深度用于存储数值,其所需的最大深度在编译期就定义好了,保存在方法的Code属性中,为 max_stack 的值。

栈中的任何一个元素都是可以任意的 Java 数据类型

  • 32bit 的类型占用一个栈单位深度
  • 64bit 的类型占用两个栈单位深度

操作数栈并非采用访问索引的方式来进行数据访问的,而是只能通过标准的入栈和出栈操作来完成一次数据访问

如果被调用的方法带有返回值的话,其返回值将会被压入当前栈帧的操作数栈中,并更新 PC 寄存器中下一条需要执行的字节码指令。

操作数栈中元素的数据类型必须与字节码指令的序列严格匹配,这由编译器在编译器期间进行验证,同时在类加载过程中的类检验阶段的数据流分析阶段要再次验证。

另外,我们说 Java 虚拟机的解释引擎是基于栈的执行引擎,其中的栈指的就是操作数栈。

5 代码追踪

我们对下面的字节码进行分析:

public void testAddOperation();
    Code:
       0: bipush        15
       2: istore_1
       3: bipush        8
       5: istore_2
       6: iload_1
       7: iload_2
       8: iadd
       9: istore_3
      10: return

执行流程如下所示:

首先执行第一条语句,PC 寄存器指向的是 0,也就是指令地址为 0,然后使用 bipush 让操作数 15 入栈。

image-20200706093131621

执行完后,让 PC + 1,指向下一行代码,下一行代码就是将操作数栈的元素存储到局部变量表 1 的位置,我们可以看到局部变量表的已经增加了一个元素

image-20210315231637502

为什么局部变量表不是从 0 开始的呢?

其实局部变量表也是从 0 开始的,但是因为 0 号位置存储的是 this 指针,所以说就直接省略了~

然后 PC+1,指向的是下一行。让操作数 8 也入栈,同时执行 istore 操作,将变量 8 存入局部变量表中

image-20210315231951852

image-20210315232043469

然后从局部变量表中,依次将数据放在操作数栈中

image-20210315232137019

image-20210315232229173

然后将操作数栈中的两个元素执行相加操作,并存储在局部变量表 3 的位置

image-20210315232313638

image-20210315232351946

最后PC寄存器的位置指向 10,也就是 return 方法,则直接退出方法

6 栈顶缓存技术

栈顶缓存技术:Top Of Stack Cashing

前面提过,基于栈式架构的虚拟机所使用的零地址指令更加紧凑,但完成一项操作的时候必然需要使用更多的入栈和出栈指令,这同时也就意味着将需要更多的指令分派(instruction dispatch)次数和内存读/写次数。

由于操作数是存储在内存中的,因此频繁地执行内存读/写操作必然会影响执行速度。为了解决这个问题,HotSpot JVM 的设计者们提出了栈顶缓存(Tos,Top-of-Stack Cashing)技术,将栈顶元素全部缓存在物理CPU的寄存器中,以此降低对内存的读/写次数,提升执行引擎的执行效率。

寄存器:指令更少,执行速度快

7 动态链接

动态链接:Dynamic Linking

每一个栈帧内部都包含一个指向运行时常量池中该栈帧所属方法的引用。包含这个引用的目的就是为了支持当前方法的代码能够实现动态链接(Dynamic Linking)。比如:invokedynamic 指令

在 Java 源文件被编译到字节码文件中时,所有的变量和方法引用都作为符号引用(symbolic Reference)保存在 class 文件的常量池里。

比如:描述一个方法调用了另外的其他方法时,就是通过常量池中指向方法的符号引用来表示的,那么动态链接的作用就是为了将这些符号引用转换为调用方法的直接引用。

image-20200706101251847

为什么需要运行时常量池?

因为在不同的方法,都可能调用常量或者方法,所以只需要存储一份即可,节省了空间

常量池的作用:就是为了提供一些符号和常量,便于指令的识别

8 方法的调用: 解析与分派

8.1 方法的调用

在 JVM 中,将符号引用转换为调用方法的直接引用与方法的绑定机制相关

  • 静态链接

当一个字节码文件被装载进 JVM 内部时,如果被调用的目标方法在编译期克制,且运行期保持不变时,这种情况下降调用方法的符号引用转换为直接引用的过程称之为静态链接

  • 动态链接

如果被调用的方法在编译期无法被确定下来,也就是说,只能够在程序运行期将调用的方法的符号转换为直接引用,由于这种引用转换过程具备动态性,因此也被称之为动态链接。

对应的方法的绑定机制为:早期绑定(Early Binding)和晚期绑定(Late Binding)。绑定是一个字段、方法或者类在符号引用被替换为直接引用的过程,这仅仅发生一次。

  • 早期绑定

早期绑定就是指被调用的目标方法如果在编译期可知,且运行期保持不变时,即可将这个方法与所属的类型进行绑定,这样一来,由于明确了被调用的目标方法究竟是哪一个,因此也就可以使用静态链接的方式将符号引用转换为直接引用。

  • 晚期绑定

如果被调用的方法在编译期无法被确定下来,只能够在程序运行期根据实际的类型绑定相关的方法,这种绑定方式也就被称之为晚期绑定。

随着高级语言的横空出世,类似于 Java 一样的基于面向对象的编程语言如今越来越多,尽管这类编程语言在语法风格上存在一定的差别,但是它们彼此之间始终保持着一个共性,那就是都支持封装、继承和多态等面向对象特性,既然这一类的编程语言具备多态特悄,那么自然也就具备早期绑定和晚期绑定两种绑定方式。

Java 中任何一个普通的方法其实都具备虚函数的特征,它们相当于 C++ 语言中的虚函数(C++ 中则需要使用关键字 virtual 来显式定义)。如果在 Java 程序中不希望某个方法拥有虚函数的特征时,则可以使用关键字 final 来标记这个方法。

8.2 虚方法和非虚方法

8.2.1 非虚方法

  • 如果方法在编译期就确定了具体的调用版本,这个版本在运行时是不可变的。这样的方法称为非虚方法。
  • 静态方法、私有方法、final 方法、实例构造器、父类方法都是非虚方法。
  • 其他方法称为虚方法。

子类对象的多态的使用前提

  • 类的继承关系
  • 方法的重写

虚拟机中提供了以下几条方法调用指令:

普通调用指令

  • invokestatic:调用静态方法,解析阶段确定唯一方法版本
  • invokespecial:调用<init>方法、私有及父类方法,解析阶段确定唯一方法版本
  • invokevirtual:调用所有虚方法
  • invokeinterface:调用接口方法

动态调用指令

  • invokedynamic:动态解析出需要调用的方法,然后执行

前四条指令固化在虚拟机内部,方法的调用执行不可人为干预,而 invokedynamic 指令则支持由用户确定方法版本。其中 invokestatic 指令和 invokespecial 指令调用的方法称为非虚方法,其余的(final 修饰的除外)称为虚方法。

8.3 invokednamic指令

JVM 字节码指令集一直比较稳定,一直到 JDK 7 中才增加了一个 invokedynamic 指令,这是 Java 为了实现【动态类型语言】支持而做的一种改进。

但是在 JDK 7 中并没有提供直接生成 invokedynamic 指令的方法,需要借助 ASM 这种底层字节码工具来产生 invokedynamic 指令。直到 JDK 8 的 Lambda 表达式的出现,invokedynamic 指令的生成,在 Java 中才有了直接的生成方式。

JDK 7 中增加的动态语言类型支持的本质是对 Java 虚拟机规范的修改,而不是对 Java 语言规则的修改,这一块相对来讲比较复杂,增加了虚拟机中的方法调用,最直接的受益者就是运行在 Java 平台的动态语言的编译器。

8.4 动态类型语言和静态类型语言

动态类型语言和静态类型语言两者的区别就在于对类型的检查是在编译期还是在运行期,满足前者就是静态类型语言,反之是动态类型语言。

说的再直白一点就是,静态类型语言是判断变量自身的类型信息;动态类型语言是判断变量值的类型信息,变量没有类型信息,变量值才有类型信息,这是动态语言的一个重要特征。

Java:String info = “java”; (Java是静态类型语言的,会先编译就进行类型检查)

JS:var name = “shkstart”; var name = 10; (运行时才进行检查)

8.5 方法重写的本质

Java 语言中方法重写的本质:

  1. 找到操作数栈顶的第一个元素所执行的对象的实际类型,记作 C。
  2. 如果在类型 C 中找到与常量中的描述符合简单名称都相符的方法,则进行访问权限校验,如果通过则返回这个方法的直接引用,查找过程结束;如果不通过,则返回 java.lang.IllegalAccessError 异常。
  3. 否则,按照继承关系从下往上依次对 C 的各个父类进行第 2 步的搜索和验证过程。
  4. 如果始终没有找到合适的方法,则抛出 java.lang.AbstractMethodsrror 异常。

IllegalAccessError 介绍

程序试图访问或修改一个属性或调用一个方法,这个属性或方法,你没有权限访问。一般的,这个会引起编译器异常。这个错误如果发生在运行时,就说明一个类发生了不兼容的改变。

image-20200706144954070

如上图所示:如果类中重写了方法,那么调用的时候,就会直接在虚方法表中查找,否则将会直接连接到 Object 的方法中。

9 方法返回地址

存放调用该方法的 PC 寄存器的值。一个方法的结束,有两种方式:

  • 正常执行完成
  • 出现未处理的异常,非正常退出

无论通过哪种方式退出,在方法退出后都返回到该方法被调用的位置。方法正常退出时,调用者的 PC 计数器的值作为返回地址,即调用该方法的指令的下一条指令的地址。而通过异常退出的,返回地址是要通过异常表来确定,栈帧中一般不会保存这部分信息。

当一个方法开始执行后,只有两种方式可以退出这个方法:

  • 执行引擎遇到任意一个方法返回的字节码指令(return),会有返回值传递给上层的方法调用者,简称正常完成出口;

    • 一个方法在正常调用完成之后,究竟需要使用哪一个返回指令,还需要根据方法返回值的实际数据类型而定。
    • 在字节码指令中,返回指令包含 ireturn(当返回值是 boolean,byte,char,short 和 int 类型时使用),lreturn(Long 类型),freturn(Float 类型),dreturn(Double 类型),areturn(对象)。另外还有一个 return 指令声明为 void 的方法,实例初始化方法,类和接口的初始化方法使用。
  • 在方法执行过程中遇到异常(Exception),并且这个异常没有在方法内进行处理,也就是只要在本方法的异常表中没有搜索到匹配的异常处理器,就会导致方法退出,简称异常完成出口。

方法执行过程中,抛出异常时的异常处理,存储在一个异常处理表,方便在发生异常的时候找到处理异常的代码

本质上,方法的退出就是当前栈帧出栈的过程。此时,需要恢复上层方法的局部变量表、操作数栈、将返回值压入调用者栈帧的操作数栈、设置 PC 寄存器值等,让调用者方法继续执行下去。

正常完成出口和异常完成出口的区别在于:通过异常完成出口退出的不会给他的上层调用者产生任何的返回值。

10 一些附加信息

栈帧中还允许携带与 Java 虚拟机实现相关的一些附加信息。例如:对程序调试提供支持的信息。

11 栈的相关面试题

  • 举例栈溢出的情况?(StackOverflowError)
    • 通过 -Xss设置栈的大小
  • 调整栈大小,就能保证不出现溢出么?
    • 不能保证不溢出
  • 分配的栈内存越大越好么?
    • 不是,一定时间内降低了 OOM 概率,但是会挤占其它的线程空间,因为整个空间是有限的。
  • 垃圾回收是否涉及到虚拟机栈?
    • 不会
  • 方法中定义的局部变量是否线程安全?
    • 具体问题具体分析
/**
 * 面试题
 * 方法中定义局部变量是否线程安全?具体情况具体分析
 * 何为线程安全?
 * 如果只有一个线程才可以操作此数据,则必是线程安全的
 * 如果有多个线程操作,则此数据是共享数据,如果不考虑共享机制,则为线程不安全
 */
public class StringBuilderTest {

    /**
     * s1 的声明方式是线程安全的
     */
    public static void method01() {
        // 线程内部创建的,属于局部变量
        StringBuilder s1 = new StringBuilder();
        s1.append("a");
        s1.append("b");
    }

    /**
     * 这个也是线程不安全的,因为有返回值,有可能被其它的程序所调用
     */
    public static StringBuilder method04() {
        StringBuilder stringBuilder = new StringBuilder();
        stringBuilder.append("a");
        stringBuilder.append("b");
        return stringBuilder;
    }

    /**
     * stringBuilder 是线程不安全的,操作的是共享数据
     */
    public static void method02(StringBuilder stringBuilder) {
        stringBuilder.append("a");
        stringBuilder.append("b");
    }


    /**
     * 同时并发的执行,会出现线程不安全的问题
     */
    public static void method03() {
        StringBuilder stringBuilder = new StringBuilder();
        new Thread(() -> {
            stringBuilder.append("a");
            stringBuilder.append("b");
        }, "t1").start();

        method02(stringBuilder);
    }

    /**
     * StringBuilder 是线程安全的,但是 String 也可能线程不安全的
     */
    public static String method05() {
        StringBuilder stringBuilder = new StringBuilder();
        stringBuilder.append("a");
        stringBuilder.append("b");
        return stringBuilder.toString();
    }
}

总结一句话就是:如果对象是在内部产生,并在内部消亡,没有返回到外部,那么它就是线程安全的,反之则是线程不安全的。

运行时数据区,是否存在 Error 和 GC?

运行时数据区是否存在 Error是否存在 GC
程序计数器
虚拟机栈
本地方法栈
方法区是(OOM)

相关资讯

    暂无相关的数据...

共有条评论 网友评论

验证码: 看不清楚?