此文章对应书中第二章，2.2.2节及第八章8.2节
1. 前言
1.1 java栈
由于跨平台性的设计，Java的指令都是根据栈来设计的。不同平台CPU架构不同，所以不能设计为基于寄存器的。
优点是跨平台，指令集小，编译器容易实现，缺点是性能下降，实现同样的功能需要更多的指令。
1.2 内存中的栈和堆
我们经常会吧JVM内存区域笼统的分为栈和堆，这里我们简单区分下栈和堆：
栈是运行时的单位，而堆是存储的单位。
即：栈解决程序的运行问题，即程序如何执行，或者说如何处理数据。堆解决的是数据存储的问题，即数据怎么放、放在哪儿。
2. JAVA虚拟机栈
2.1 是什么？
java虚拟机栈（JVM Stack），早期也叫java栈。每个线程在创建时都会创建一个虚拟机栈，其内部保存一个个的栈帧（Stack Frame），对应着一次次的Java方法调用。
- 是线程私有的。
例：
2.2 生命周期
java虚拟机栈的生命周期和线程一致。
2.3 作用
每个栈帧用于存储方法的局部变量表（8种基本数据类型，对象的引用地址）、操作数栈、动态连接及部分结果，并参与方法的调用和返回。每一个方法被调用直至调用完毕就伴随着一个栈帧在虚拟机栈中的入栈出栈的过程。
这些数据类型在局部变量表中的存储空间以聚标变量槽（Slot）来表示。long和double占用2个变量槽，其余的占用一个。局部变量表所需的内存空间在编译期完成分配，当进入一个方法时，这个方法需要在栈帧种分配多大的局部变量空间完全确定的，在方法运行期间不会改变局部变量表的大小。（这里的大小指的时变量槽的数量，虚拟机真正使用多大的内存空间来实现一个变量槽，比如一个变量槽占用32比特，64比特或更多，具体的大小由虚拟机实现决定）
2.4 栈的优点
-
栈是一种快速有效的分配存储方式，访问速度仅次于程序计数器
-
JVM对栈的操作只有2个：
-
每个方法执行，伴随着进栈
-
执行结束后的出栈工作
-
对于栈来说不存在垃圾回收问题（但是存在StackOverflowError）
2.5 栈中可能出现的异常：
Java虚拟机规范允许栈的大小是动态的或者是固定不变的。
-
如果采用固定大小的Java虚拟机栈，那每一个线程的Java虚拟机栈容量可以在线程创建的时候独立选定。如果线程请求分配的栈容量超过Java虚拟机栈允许的最大容量，Java虚拟机会抛出一个StackOverflowError。
-
比较典型的是没有跳出的递归调用
-
如果Java虚拟机栈可以动态扩展，并且尝试扩展时无法申请到足够的内存，会抛出OutOfMemoryError（注意HotSpot虚拟机的栈容量是不可以动态扩展的）
演示：
// 栈异常演示
public class StackError {
public static void main(String[] args) {
main(args);
}
}
2.6 设置栈的大小：-Xss size
我们写个例子来演示下：（在idea的edit configurations的vm options中设置-Xss256k）
/**
* 演示StackOverflowError
*
* 不设置时 count：19770
* 设置后：count:4144
*/
public class StackErrorTest {
private static int count = 1;
public static void main(String[] args) {
System.out.println(count);
count++;
main(args);
}
}
演示：
3. 栈的存储单位（书中第八章8.2节）
3.1 栈中存储什么？
- 每个线程都有自己的栈，栈中的数据以栈帧的格式存在
- 在这个线程上正在执行的每个方法都各自对应一个栈帧（一对一）
- 栈帧是一个内存区块，是一个数据集，维系着方法执行过程中的各种数据信息
3.2 栈运行原理
-
JVM对栈的操作只有2个：对栈帧的入栈和出栈，遵循后进先出原则
-
在一条活动线程中，一个时间点上，只会有一个活动的栈帧。即当前正在执行的方法的栈帧是有效的，这个栈帧被称为当前栈帧，对应的方法是当前方法，定义这个方法的类是当前类
-
执行引擎运行的所有字节码指令只针对当前栈帧进行操作
-
如果在该方法中调用了其他方法，对应的新的栈帧会被创建出来，放在栈的顶端，称为新的当前帧
-
不同线程中所包含的栈帧是不允许相互引用的
-
如果当前方法调用了其他方法，方法返回之际，当前栈帧会传回此方法的运行结果给前一个栈帧然后出栈，使得前一个栈帧重新成为当前栈帧
-
Java方法有2种返回函数的方式，无论那种返回都会导致出栈
-
return返回
-
抛出异常（没有处理，try catch算是处理了 ）
3.3 栈帧的内部结构
- 局部变量表
- 操作数栈（表达式栈）
- 动态链接（指向运行时常量池的方法引用）
- 方法返回地址（方法正常退出或者异常推出的定义）
- 一些附加信息
3.4 局部变量表
- 也被称为局部变量数组或本地变量表
- 定义为一个数字数组，主要用于存储方法参数和定义在方法体内的局部变量，这些数据类型包括各类基本数据类型，对象引用，以及returnAddress（返回值）类型。
- 由于局部变量表是建立在线程的栈上，是线程的私有数据，因此不存在数据安全问题。
- 局部变量表所需的容量大小是在java源码编译期（即java代码被编译成Class文件时）确定下来的，并保存在方法的Code属性的maximum local variables数据项中。在方法运行期间不会改变局部变量表的大小的。
- 方法嵌套调用的次数由栈的大小决定。一般来说，栈越大，方法嵌套调用次数越多。对一个函数而言，它的参数和局部变量越多，使得局部变量表膨胀，它的栈帧就越大，以满足方法调用所需传递的信息增大的需求。进而函数调用就会占用更多的栈空间，导致其嵌套调用次数就会减少。
- 局部变量表中的变量只在当前方法调用中有效。在方法执行时，虚拟机通过使用局部变量表完成参数值到参数变量列表的传递过程。当方法调用结束后，随着方法栈帧的销毁，局部变量表也会随之销毁。
3.4.1 举例说明：局部变量表所需的容量大小是在编译期确定下来的
反编译如下代码：
public class LocalVariablesTest {
private int count = 0;
public static void main(String[] args) {
LocalVariablesTest test = new LocalVariablesTest();
int num = 10;
test.test1();
}
public void test1() {
Date date = new Date();
String name1 = "baidu.com";
String info = test2(date, name1);
System.out.println(date + name1);
}
public String test2(Date dateP, String name2) {
dateP = null;
name2 = "xiexu";
double weight = 185.5;//占据两个slot
char gender = '男';
return dateP + name2;
}
}
- 利用 JClassLib 也可以查看局部变量的个数
3.4.2 关于Slot的理解
-
参数值的存放总是从局部变量数组索引 0 的位置开始，到数组长度-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处，其余的参数按照参数表顺序继续排列。
3.4.2.1 this的槽的index为0代码演示：
private int count;
//构造器
public LocalVariablesTest1() {
this.count = 1;
}
//实例方法
public void test1() {
Date date = new Date();
double k = 1d; // 占据2个slot
String name1 = "baidu.com";
test2(date, name1);
System.out.println(date + name1);
}
构造方法：
test1方法：可以看到this的index位置为1（下标为0 ），而double类型的k的位置是3，到了string类型的name就直接到了5，说明double占用了2个位置
3.4.2.2 static方法无法调用this：
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);
}
可以看到局部变量表中并没有this，所以无法调用
3.4.3 Slot的重复利用：
栈帧中的局部变量表中的槽位是可以重用的，如果一个局部变量过了其作用域，那么在其作用域之后申明的新的局部变量就很有可能会复用过期局部变量的槽位，从而达到节省资源的目的。
我们来看一个方法：
public class LocalVariablesTest {
private int a = 0;
public void test() {
int a = 0;
{
int b= 0; // 变量b只在当前方法块中有效，执行完方法块后变量b就被销毁了
b = a + 1;
}
// 变量c使用之前已经销毁的变量b占据的slot的位置
int c = a + 1;
}
}
我们再看看jclasslib中：可以看出原来b用的index为2的slot，可是b的作用域只有4行，很快就结束了，此时定义了一个新的c，所以c直接用的index为2的变量槽。
3.4.4 各种变量对比
参数表分配完毕之后，再根据方法体内定义的变量的顺序和作用域进行分配
1、 成员变量：在使用前，都经过默认初始化赋值（如int会默认初始化为0）；
1、 实例变量：随着对象的创建，会在对空间中分配变量空间，并进行默认赋值；
2、 类变量：我们知道类变量表有两次初始化的机会，第一次是在“准备阶段”，执行系统初始化，对类变量设置零值，另一次则是在“初始化”阶段，赋予程序员在代码中定义的初始值；
2、 局部变量表：和类变量初始化不同的是，局部变量表不存在系统初始化的过程，这意味着一旦定义了局部变量则必须人为的初始化，否则无法使用；
public void test（）{
int i;
// 这样的代码是错误的，没有赋值不能够使用。
System. out. println(i);
}
3.4.5 补充问题：
- 在栈帧中，与性能调优关系最为密切的部分就是前面提到的局部变量表。在方法执行时，虚拟机使用局部变量表完成方法的传递。
- 局部变量表中的变量也是重要的垃圾回收根节点，只要被局部变量表中直接或间接引用的对象都不会被回收。
- 局部变量在使用前一定要初始化 ，它并不会像成员变量或者类变量那样被默认初始化
3.5 操作数栈
3.5.1 操作数栈的特点
-
每一个独立的栈帧中除了包含局部变量表意外，还包含一个后进先出的操作数栈，也可以称之为表达式栈
-
操作数栈，在方法执行过程中，根据字节码指令，往栈中写入数据或提取数据，即入栈/出栈
-
某些字节码指令将之压入操作数栈，其余的字节码指令将操作数取出
-
比如：执行复制、交换、求和等操作
3.5.2 操作数栈的执行过程：
-
操作数栈，主要用于保存计算过程的中间结果，同时作为计算过程中变量临时的存储空间。
-
操作数栈就是JVM执行引擎的一个工作区，当一个方法刚开始执行的时候，一个新的栈帧也会随之被创建出来，这个时候方法的操作数栈是空的（这个时候数组是创建好并且是长度固定的，但数组的内容为空）
-
每一个操作数栈都会拥有一个明确的栈深度用于存储数值，其所需的最大深度在编译期就定义好了，保存在方法的Code属性中，为maxstack的值。
-
栈中的任何一个元素都是可以任意的Java数据类型
-
32bit的类型占用一个栈单位深度
-
64bit的类型占用两个栈单位深度
-
操作数栈并非采用访问索引的方式来进行数据访问的，而是只能通过标准的入栈和出栈操作来完成一次数据访问
-
如果被调用的方法带有返回值的话，其返回值将会被压入当前栈帧的操作数栈中，并更新PC寄存器中下一条需要执行的字节码指令。
-
操作数栈中元素的数据类型必须与字节码指令的序列严格匹配，这由编译器在编译器期间进行验证，同时在类加载过程中的类检验阶段的数据流分析阶段要再次验证。
-
另外，我们说Java虚拟机的解释引擎是基于栈的执行引擎，其中的栈指的就是操作数栈。
3.5.3 执行过程代码及图例解释：
public class OperandStackTest {
public void testAddOperation() {
// byte,short,char,boolean都以int型保存
byte i = 15;
int j = 8;
int k = i + j;
}
}
// 字节码指令：
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
操作指令详解：
1、 最开始操作数栈、局部变量表都为空；PC寄存器中记录下一步指令地址0；
2、 指令0：此时寄存器中存放0，执行0，将15入栈到操作数栈；完成后PC寄存器记录移到指令地址2；
3、 指令2：此时寄存器中存放2，执行2，将15出栈，存放到局部变量表中1的位置（0是this）；PC寄存器记录3；
4、 指令3：此时寄存器中存放3，执行3，将8入栈；PC寄存器记录5；
5、 指令5：执行5，将8出栈，存放到局部变量表中；PC寄存器记录6；
6、 指令6：此时寄存器中存放6，执行6，读取局部变量表中的15，压入操作数栈；PC寄存器记录7；
7、 指令7：此时寄存器中存放7，执行7，读取局部变量表中的8，压入操作数栈；PC寄存器记录8；
8、 指令8：此时寄存器中存放8，执行8，此命令是add操作将8和15出栈，通过执行引擎将字节码指令翻译成机器指令交给CPU计算，计算后的结果为23，将23压入操作数栈；PC寄存器记录9；
9、 指令9：此时寄存器中存放9，执行9，将23出栈，记录到局部变量表中索引为3的位置；PC寄存器记录10；
从中同样可以看出我们的局部变量表大小为4（包含0位的this），操作数栈深度为2，代码量为11
3.5.4 如果是带有返回值的多个方法：
// 如果被调用的方法带有返回值的话，其返回值将会被压入当前栈帧的操作数栈中
public int getSum() {
int m = 10; // 因为10还是byte类型的，所以字节码中可以看出用的是bipush
int n = 20;
int k = m + n;
int t = 8000; // 8000是short类型，所以是sipush
int s = 80000;// 而80000就是int型了，所以用到了Integer包装类
return k;
}
public void testGetSum() {
//获取上一个栈桢返回的结果，并保存在操作数栈中
int i = getSum();
int j = 10;
}
3.6 栈顶缓存技术(Top Of Stack Cashing)
前面提过，基于栈式架构的虚拟机所使用的零地址指令更加紧凑，但完成一项操作的时候必然需要使用更多的入栈和出栈指令，这同时也就意味着将需要更多的指令
分派（instruction dispatch）次数和内存读/写次数。
由于操作数是存储在内存中的，因此频繁地执行内存读/写操作必然会影响执行速度。为了解决这个问题，HotSpot JVM的设计者们提出了栈顶缓存（Tos，Top-of-Stack Cashing）技术，将栈顶元素全部缓存在物理CPU的寄存器中，以此降低对内存的读/写次数，提升执行引擎的执行效率。
寄存器的主要优点：指令更少，执行速度快
3.7 动态链接（或指向运行时常量池的方法引用）
- 每个栈帧内部都包含一个指向运行时常量池中该栈帧所属方法的引用。包含这个引用的目的是为了支持当前方法的代码能够实现动态链接。比如invokedynamic指令
- 在java源文件被编译到字节码文件中时，所有的变量和方法引用都作为符号引用保存在class文件的常量池中。比如：描述一个方法调用了另外的其他方法时，就是通过常量池中指向方法的符号引用来表示的，那么动态链接的作用就是为了将这些符号引用转换为调用方法的直接引用。
我的理解：运行时常量池是线程共享的，在编译期生成的，一个类只有一份内容放在常量池中，每一个栈帧中的一个单独的方法需要调用那个类的方法时，就通过动态链接指向那个常量池中的方法。
3.7.1 代码展示：
在Java源文件被编译到字节码文件中时，所有的变量和方法引用都作为符号引用（Symbolic Reference）保存在class文件的常量池里
代码：
public class DynamicLinkingTest {
int num = 10;
public void methodA(){
System.out.println("methodA()....");
}
public void methodB(){
System.out.println("methodB()....");
methodA();
num++;
}
}
字节码：
在字节码指令中，methodB( ) 方法中通过 invokevirtual #7 指令调用了方法 A
那么 #7 是什么呢？
public void methodB();
descriptor: ()V
flags: ACC_PUBLIC
Code:
stack=3, locals=1, args_size=1
0: getstatic #3 // Field java/lang/System.out:Ljava/io/PrintStream;
3: ldc #6 // String methodB()....
5: invokevirtual #5 // Method java/io/PrintStream.println:(Ljava/lang/String;)V
8: aload_0
9: invokevirtual #7 // Method methodA:()V
12: aload_0
13: dup
14: getfield #2 // Field num:I
17: iconst_1
18: iadd
19: putfield #2 // Field num:I
22: return
LineNumberTable:
line 12: 0
line 13: 8
line 14: 12
line 15: 22
LocalVariableTable:
Start Length Slot Name Signature
0 23 0 this Lcn/sxt/java1/DynamicLinkingTest;
往上面翻，找到常量池的定义：#7 = Methodref #8.#31
先找 #8 ：
#8 = Class #32 ：去找 #32
#32 = Utf8 cn/sxt/java1/DynamicLinkingTest
结论：通过 #8 我们找到了 DynamicLinkingTest 这个类
再来找 #31：
#31 = NameAndType #19:#13 ：去找 #19 和 #13
#19 = Utf8 methodA ：方法名为 methodA
#13 = Utf8 ()V ：方法没有形参，返回值为 void
结论：通过 #7 我们就能找到需要调用的 methodA( ) 方法，并进行调用
Constant pool:
#1 = Methodref #9.#23 // java/lang/Object."<init>":()V
#2 = Fieldref #8.#24 // cn/sxt/java1/DynamicLinkingTest.num:I
#3 = Fieldref #25.#26 // java/lang/System.out:Ljava/io/PrintStream;
#4 = String #27 // methodA()....
#5 = Methodref #28.#29 // java/io/PrintStream.println:(Ljava/lang/String;)V
#6 = String #30 // methodB()....
#7 = Methodref #8.#31 // cn/sxt/java1/DynamicLinkingTest.methodA:()V
#8 = Class #32 // cn/sxt/java1/DynamicLinkingTest
#9 = Class #33 // java/lang/Object
#10 = Utf8 num
#11 = Utf8 I
#12 = Utf8 <init>
#13 = Utf8 ()V
#14 = Utf8 Code
#15 = Utf8 LineNumberTable
#16 = Utf8 LocalVariableTable
#17 = Utf8 this
#18 = Utf8 Lcn/sxt/java1/DynamicLinkingTest;
#19 = Utf8 methodA
#20 = Utf8 methodB
#21 = Utf8 SourceFile
#22 = Utf8 DynamicLinkingTest.java
#23 = NameAndType #12:#13 // "<init>":()V
#24 = NameAndType #10:#11 // num:I
#25 = Class #34 // java/lang/System
#26 = NameAndType #35:#36 // out:Ljava/io/PrintStream;
#27 = Utf8 methodA()....
#28 = Class #37 // java/io/PrintStream
#29 = NameAndType #38:#39 // println:(Ljava/lang/String;)V
#30 = Utf8 methodB()....
#31 = NameAndType #19:#13 // methodA:()V
#32 = Utf8 cn/sxt/java1/DynamicLinkingTest
#33 = Utf8 java/lang/Object
#34 = Utf8 java/lang/System
#35 = Utf8 out
#36 = Utf8 Ljava/io/PrintStream;
#37 = Utf8 java/io/PrintStream
#38 = Utf8 println
#39 = Utf8 (Ljava/lang/String;)V3.7.2 为什么要用常量池呢？
因为在不同的方法，都可能调用常量或者方法，所以只需要存储一份即可，然后记录其引用即可，节省了空间常量池的作用：就是为了提供一些符号和常量，便于指令的识别
3.8 方法返回地址
-
存储的调用该方法的PC寄存器的值
-
一个方法的结束，有两种方式：
-
正常执行完成
-
出现未处理的异常，非正常退出
-
无论通过哪种方式退出，在方法退出后都返回到该方法被调用的位置。方法正常退出时，调用者的pc寄存器的值作为返回地址，即调用该方法的指令的下一条指令的地址。而通过异常退出的，返回地址是要通过异常表来确定，栈帧中一般不会保存这部分信息。
我的理解：一个方法执行完了，PC寄存器会存储下一条要执行的指令，比如说下一个方法，这个指令地址就作为方法返回地址返回交给执行引擎，执行引擎就知道下一步要执行的操作（指令）
本质上，方法的退出就是当前栈帧出栈的过程。此时，需要恢复上层方法的局部变量表、操作数栈、将返回值压入调用者栈帧的操作数栈、设置PC寄存器值等，让调用者方法继续执行下去。
正常完成出口和异常完成出口的区别在于：通过异常完成出口退出的不会给他的上层调用者产生任何的返回值。
3.8.1 方法退出的两种方式
当一个方法开始执行后，只有两种方式可以退出这个方法：
1、 执行引擎遇到任意一个方法返回的字节码指令（return），会有返回值传递给上层的方法调用者，简称正常完成出口；
1、 一个方法在正常调用完成之后，究竟需要使用哪一个返回指令，还需要根据方法返回值的实际数据类型而定；
2、 在字节码指令中，返回指令包含：；
1. ireturn：当返回值是boolean，byte，char，short和int类型时使用
2. lreturn：Long类型
3. freturn：Float类型
4. dreturn：Double类型
5. areturn：引用类型
6. return：返回值类型为void的方法、构造器、类和接口的初始化方法2、 在方法执行过程中遇到异常（Exception），并且这个异常没有在方法内进行处理，也就是只要在本方法的异常表中没有搜索到匹配的异常处理器，就会导致方法退出，简称异常完成出口；
方法执行过程中，抛出异常时的异常处理，存储在一个异常处理表，方便在发生异常的时候找到处理异常的代码
例如这一段代码的异常处理表：其中，4，8，11是字节码指令行号。
翻译一下就是：如果4到8出现了异常情况，就按照11来处理。
异常处理表：
代码：
指令对应行号：
3.9 附加信息
栈帧中还允许携带与Java虚拟机实现相关的一些附加信息。例如：对程序调试提供支持的信息。
在讨论概念时，一般会把动态链接、方法返回地址和其他附加信息全部归为一类，称为栈帧信息。
4. 一些面试题
4.1 举例栈溢出的情况（StackOverflowError）
递归调用。
通过-Xss设置栈的大小
超过内存大小，OOM
4.2 调整栈的大小，就能保证不出现溢出吗？
不能，计算机硬件有最大的内存限制
4.3 垃圾回收是否会涉及到虚拟机栈
不会，
4.4 分配的栈空间越大越好吗？
不是，一定时间内降低了栈溢出的概率，但是会挤占其它的线程空间，因为整个虚拟机的内存空间是有限的
4.5 方法中定义的局部变量是否线程安全？
具体问题具体分析。
总结一下就是内部产生并且在内部消亡的就是线程安全的，否则就是线程不安全的。
/**
* 面试题：
* 方法中定义的局部变量是否线程安全？
* 具体情况具体分析
* 内部创建，内部消亡就是线程安全的，否则就不是的
*
* 何为线程安全？
* 如果只有一个线程操作此数据，则必是线程安全的。
* 如果有多个线程操作此数据，则此数据是共享数据。如果不考虑同步机制的话，会存在线程安全问题。
*
*/
public class StringBuilderTest {
// s1的声明方式是线程安全的
// s1是这个线程单独持有的，不会被其他线程访问
public static void method1() {
// StringBuilder线程不安全，StringBuffer是线程安全的
StringBuilder s1 = new StringBuilder();
s1.append("a");
s1.append("b");
}
// s1的操作过程是线程不安全的
// 看main方法，新建了一个stringBuilder对象，
// 创建了一个分线程对此对象进行添加，主线程也是对这个对象进行添加
// 他们2个就可能同时进行操作，就是线程不安全的
public static void method2(StringBuilder s1) {
s1.append("a");
s1.append("b");
}
// s1的声明方式是线程不安全的
// s1的定义是安全的，但是因为有个s1的返回值，返回出去了，很多线程会来抢占这个返回值，就是线程不安全的
// 内部创建，但是并没有消亡
public static StringBuilder method3() {
StringBuilder s1 = new StringBuilder();
s1.append("a");
s1.append("b");
return s1;
}
// s1的操作是线程安全的
// 最后的返回值并不是s1，s1在内部已经消亡了，所以是线程安全的
// 其中toString()方法是重新创建了一个String对象
public static String method4() {
StringBuilder s1 = new StringBuilder();
s1.append("a");
s1.append("b");
return s1.toString();
}
public static void main(String[] args) {
StringBuilder s = new StringBuilder();
new Thread(() -> {
s.append("a");
s.append("b");
}).start();
method2(s);
}
}