JVM优化 - 第三天

Tomcat8的优化

看懂Java底层字节码

编码的优化建议

1、Tomcat8优化

对于tomcat的优化，主要是从2个方面入手，一是，tomcat自身的配置，另一个是

tomcat所执行的jvm虚拟机器的调优。

下面我们将从这2个方面进行讲解。

1.1、Tomcat配置优化1.1.1、部署安装tomcat8 下载并安装：

https://tomcat.apache.org/download-80.cgi

cd /tmp

wget http://mirrors.tuna.tsinghua.edu.cn/apache/tomcat/tomcat‐ 8/v8.5.34/bin/apache‐tomcat‐8.5.34.tar.gz

tar ‐xvf apache‐tomcat‐8.5.34.tar.gz cd apache‐tomcat‐8.5.34/conf

#修改配置档案，配置tomcat的管理使用者

vim tomcat‐users.xml #写入如下内容：

#储存退出

#如果是tomcat7，配置了tomcat使用者就可以登入系统了，但是tomcat8中不行，还需要修改另一个配置档案，否则访问不了，提示403

vim webapps/manager/META‐INF/context.xml

#将

#储存退出即可

#启动tomcat

cd /tmp/apache‐tomcat‐8.5.34/bin/

./startup.sh && tail ‐f …/logs/catalina.out

#开启浏览器进行测试访问http://192.168.40.133:8080/

点选“Server Status”，输入使用者名称、密码进行登入，tomcat/tomcat

进入之后即可看到服务的资讯。

1.1.2、禁用AJP连线

在服务状态页面中可以看到，预设状态下会启用AJP服务，并且占用8009埠。

什么是AJP呢？

AJP（Apache JServer Protocol）

AJPv13协议是面向包的。WEB服务器和Servlet容器通过TCP连线来互动；为了节省SOCKET建立的昂贵代价，WEB服务器会尝试维护一个永久TCP连线到servlet容器，并且在多个请求和响应周期过程会重用连线。

我们一般是使用Nginx+tomcat的架构，所以用不着AJP协议，所以把AJP联结器禁用。修改conf下的server.xml档案，将AJP服务禁用掉即可。

重启tomcat，检视效果。

可以看到AJP服务以及不存在了。

1.1.3、执行器（执行绪池）

在tomcat中每一个使用者请求都是一个执行绪，所以可以使用执行绪池提高效能。

修改server.xml档案：

prestartminSpareThreads=true maxQueueSize=100/>

引数说明：

maxThreads：最大并发数，预设设定 200，一般建议在 500 ~ 1000，根据硬件设施和业务来判断

minSpareThreads：Tomcat 初 始 化 时 创 建 的 线 程 数 ， 默 认 设 置 25 prestartminSpareThreads： 在 Tomcat 初始化的时候就初始化 minSpareThreads 的引数值，如果不等于 true，minSpareThreads 的值就没啥效果了

maxQueueSize，最大的等待伫列数，超过则拒绝请求

‐‐>

redirectPort=8443 />

储存退出，重启tomcat，检视效果。

在页面中显示最大执行绪数为-1，这个是正常的，仅仅是显示的问题，实际使用的指定的值。

也有人遇到这样的问

题：https://blog.csdn.net/weixin_38278878/article/details/80144397

1.1.4、3种执行模式

tomcat的执行模式有3种：

1.bio

预设的模式,效能非常低下,没有经过任何优化处理和支援.

2.nio

nio(new I/O)，是Java SE 1.4及后续版本提供的一种新的I/O操作方式(即java.nio包及其子包)。Java nio是一个基于缓冲区、并能提供非阻塞I/O操作的Java API，因此nio 也被看成是non-blocking I/O的缩写。它拥有比传统I/O操作(bio)更好的并发执行效能。

3.apr

安装起来最困难,但是从操作系统级别来解决异步的IO问题,大幅度的提高效能.

推荐使用nio，不过，在tomcat8中有最新的nio2，速度更快，建议使用nio2. 设定nio2：

connectionTimeout=20000 redirectPort=8443 />

可以看到已经设定为nio2了。

1.2、部署测试用的java web专案

为了方便测试效能，我们将部署一个java web专案，这个专案本身和本套课程没有什么关系，仅仅用于测试。

注意：这里在测试时，我们使用一个新的tomcat，进行测试，后面再对其进行优化 调整，再测试。

1.2.1、建立dashboard数据库

在资料中找到sql指令码档案dashboard.sql，在linux服务器上执行。

cat dashboard.sql mysql ‐uroot ‐proot

建立完成后，可以看到有3张表。

1.2.2、部署web应用

在资料中找到itcat-dashboard-web.war，上传到linux服务器，进行部署安装。

cd /tmp/apache‐tomcat‐8.5.34/webapps

rm ‐rf *

mkdir ROOT

cd ROOT/

rz上传war包

jar ‐xvf itcat‐dashboard‐web.war rm ‐rf itcat‐dashboard‐web.war

#修改数据库配置档案

cd /tmp/apache‐tomcat‐8.5.34/webapps/ROOT/WEB‐INF/classes vim jdbc.properties

#这里根据自己的实际情况进行配置

jdbc.driverClassName=com.mysql.jdbc.Driver

jdbc.url=jdbc:mysql://node01:3306/dashboard? useUnicode=true&characterEncoding=utf8&autoReconnect=true&allowMultiQueri es=true

jdbc.username=root

jdbc.password=root

重新启动tomcat。

访问首页，检视是否已经启动成功：http://192.168.40.133:8080/index

1.3、使用Apache JMeter进行测试

Apache Jmeter是开源的压力测试工具，我们借助于此工具进行测试，将测试出tomcat

的吞吐量等资讯。

1.3.1、下载安装

下载地址：http://jmeter.apache.org/download_jmeter.cgi

安装：直接将下载好的zip压缩包进行解压即可。

进入bin目录，找到jmeter.bat档案，双机开启即可启动。

1.3.2、修改主题和语言

预设的主题是黑色风格的主题并且语言是英语，这样不太方便使用，所以需要修改下主题和中文语言。

主题修改完成。

接下来设定语言为简体中文。

1.3.3、建立首页的测试用例

第一步：储存测试用例

第二步：新增执行绪组，使用执行绪模拟使用者的并发

1000个执行绪，每个执行绪循环10次，也就是tomcat会接收到10000个请求。

第三步：新增http请求

第四步：新增请求监控

1.3.4、启动、进行测试

1.3.5、聚合报告

在聚合报告中，重点看吞吐量。

1.4、调整tomcat引数进行优化

通过上面测试可以看出，tomcat在不做任何调整时，吞吐量为73次/秒。

1.4.1、禁用AJP服务

可以看到，禁用AJP服务后，吞吐量会有所提升。

当然了，测试不一定准确，需要多测试几次才能看出是否有提升。

1.4.2、设定执行绪池

通过设定执行绪池，调整执行绪池相关的引数进行测试tomcat的效能。

1.4.2.1、最大执行绪数为500，初始为50

prestartminSpareThreads=true/>

测试结果：

吞吐量为128次/秒，效能有所提升。

1.4.2.2、最大执行绪数为1000，初始为200

prestartminSpareThreads=true/>

吞吐量为151，效能有所提升。

1.4.2.3、最大执行绪数为5000，初始为1000

是否是执行绪数最多，速度越快呢？ 我们来测试下。

prestartminSpareThreads=true/>

可以看到，虽然最大执行绪已经设定到5000，但是实际测试效果并不理想，并且平均的响 应时间也边长了，所以单纯靠提升执行绪数量是不能一直得到效能提升的。

1.4.2.4、设定最大等待伫列数

预设情况下，请求传送到tomcat，如果tomcat正忙，那么该请求会一直等待。这样虽然 可以保证每个请求都能请求到，但是请求时间就会边长。

有些时候，我们也不一定要求请求一定等待，可以设定最大等待伫列大小，如果超过就不等待了。这样虽然有些请求是失败的，但是请求时间会虽短。典型的应用：12306。

prestartminSpareThreads=true maxQueueSize=100/>

测试结果：

平均响应时间：3.1秒响应时间明显缩短

错误率：49.88%

错误率提升到一半，也可以理解，最大执行绪为500，测试的并发为1000 吞吐量：238次/秒

吞吐量明显提升

结论：响应时间、吞吐量这2个指标需要找到平衡才能达到更好的效能。

1.4.3、设定nio2的执行模式

将最大执行绪设定为500进行测试：

maxThreads=500 minSpareThreads=50 prestartminSpareThreads=true/>

connectionTimeout=20000

redirectPort=8443 />

可以看到，平均响应时间有缩短，吞吐量有提升，可以得出结论：nio2的效能要高于

nio。

1.5、调整JVM引数进行优化

接下来，测试通过jvm引数进行优化，为了测试一致性，依然将最大执行绪数设定为500， 启用nio2执行模式。

1.5.1、设定并行垃圾回收器

#年轻代、老年代均使用并行收集器，初始堆内存64M，最大堆内存512M JAVA_OPTS=‐XX:+UseParallelGC ‐XX:+UseParallelOldGC ‐Xms64m ‐Xmx512m ‐ XX:+PrintGCDetails ‐XX:+PrintGCTimeStamps ‐XX:+PrintGCDateStamps ‐ XX:+PrintHeapAtGC ‐Xloggc:../logs/gc.log

测试结果与预设的JVM引数结果接近。（执行了2次测试，结果是第二次测试的结果）

1.5.2、检视gc日志档案

将gc.log档案上传到gceasy.io检视gc中是否存在问题。

在报告中显示，在5次GC时，系统所消耗的时间大于使用者时间，这反应出的服务器的效能存在瓶颈，排程CPU等资源所消耗的时间要长一些。

问题二：

可以关键指标中可以看出，吞吐量表现不错，但是gc时，执行绪的暂停时间稍有点长。

问题三：

通过GC的统计可以看出：

年轻代的gc有74次，次数稍有多，说明年轻代设定的大小不合适需要调整

FullGC有8次，说明堆内存的大小不合适，需要调整

问题四：

从GC原因的可以看出，年轻代大小设定不合理，导致了多次GC。

1.5.3、调整年轻代大小

JAVA_OPTS=‐XX:+UseParallelGC ‐XX:+UseParallelOldGC ‐Xms128m ‐Xmx1024m ‐ XX:NewSize=64m ‐XX:MaxNewSize=256m ‐XX:+PrintGCDetails ‐ XX:+PrintGCTimeStamps ‐XX:+PrintGCDateStamps ‐XX:+PrintHeapAtGC ‐ Xloggc:../logs/gc.log

将初始堆大小设定为128m，最大为1024m

初始年轻代大小64m，年轻代最大256m

从测试结果来看，吞吐量以及响应时间均有提升。

检视gc日志：

可以看到GC次数要明显减少，说明调整是有效的。

1.5.4、设定G1垃圾回收器

#设定了最大停顿时间100毫秒，初始堆内存128m，最大堆内存1024m JAVA_OPTS=‐XX:+UseG1GC ‐XX:MaxGCPauseMillis=100 ‐Xms128m ‐Xmx1024m ‐ XX:+PrintGCDetails ‐XX:+PrintGCTimeStamps ‐XX:+PrintGCDateStamps ‐ XX:+PrintHeapAtGC ‐Xloggc:../logs/gc.log

测试结果：

可以看到，吞吐量有所提升，评价响应时间也有所缩短。

1.5.5、小结

通过上述的测试，可以总结出，对tomcat效能优化就是需要不断的进行调整引数，然后 测试结果，可能会调优也可能会调差，这时就需要借助于gc的视觉化工具来看gc的情 况。再帮我我们做出决策应该调整哪些引数。

2、JVM字节码

对于程式本身的优化，可以借鉴很多前辈们的经验，但是有些时候，在从源代码角度方面 分析的话，不好鉴别出哪个效率高，如对字串拼接的操作，是直接“+”号拼接效率高还 是使用StringBuilder效率高？

这个时候，就需要通过检视编译好的class档案中字节码，就可以找到答案。

我们都知道，java编写应用，需要先通过javac命令编译成class档案，再通过jvm执行，

jvm执行时是需要将class档案中的字节码载入到jvm进行执行的。

2.1、通过javap命令检视class档案的字节码内容

首先，看一个简单的Test1类的程式码：

package cn.itcast.jvm;

public class Test1 {

public static void main(String[] args) {

int a = 2; int b = 5; int c = b ‐ a;

System.out.println(c);

}

}

通过javap命令检视class档案中的字节码内容：

javap ‐v Test1.class > Test1.txt

javap用法: javap

其中, 可能的选项包括:

‐help ‐‐help ‐?

‐version

‐v ‐verbose

‐l

‐public

‐protected

‐package

‐p ‐private

‐c

‐s

‐sysinfo

‐constants

‐classpath

‐cp

‐bootclasspath

检视Test1.txt档案，内容如下：

Classfile /F:/code/itcast‐jvm/itcast‐jvm‐ test/target/classes/cn/itcast/jvm/Test1.class

Last modified 2018‐9‐27; size 577 bytes

MD5 checksum 4214859db3543c0c783ec8a216a4795f Compiled from Test1.java

public class cn.itcast.jvm.Test1 minor version: 0

major version: 52

flags: ACC_PUBLIC, ACC_SUPER

Constant pool:

#1 = Methodref #5.#23 // java/lang/Object.: ()V

#2 = Fieldref #24.#25 // java/lang/System.out:Ljava/io/PrintStream;

#3 = Methodref #26.#27 // java/io/PrintStream.println: (I)V

#28 = Utf8 cn/itcast/jvm/Test1

#29 = Utf8 java/lang/Object

#30 = Utf8 java/lang/System

#31 = Utf8 out

#32 = Utf8 Ljava/io/PrintStream;

#33 = Utf8 java/io/PrintStream

#34 = Utf8 println

#35 = Utf8 (I)V

{

public cn.itcast.jvm.Test1(); descriptor: ()V

flags: ACC_PUBLIC Code:

stack=1, locals=1, args_size=1 0: aload_0

1: invokespecial #1 // Method

java/lang/Object.:()V

4: return LineNumberTable:

line 3: 0 LocalVariableTable:

Start Length Slot Name Signature

0 5 0 this Lcn/itcast/jvm/Test1;

public static void main(java.lang.String[]); descriptor: ([Ljava/lang/String;)V

flags: ACC_PUBLIC, ACC_STATIC

Code:

stack=2, locals=4, args_size=1 0: iconst_2

1: istore_1

2: iconst_5

3: istore_2

4: iload_2

5: iload_1

6: isub

7: istore_3

8: getstatic #2 // Field java/lang/System.out:Ljava/io/PrintStream;

11: iload_3

12: invokevirtual #3 // Method

java/io/PrintStream.println:(I)V

15: return LineNumberTable:

line 6: 0

line 7: 2

line 8: 4

line 9: 8

line 10: 15

LocalVariableTable:

Start

0 Length

16 Slot

0 Name

args Signature

[Ljava/lang/String;

2 14 1 a I

4 12 2 b I

8 8 3 c I

}

SourceFile: Test1.java

内容大致分为4个部分：

第一部分：显示了生成这个class的java原始档、版本资讯、生成时间等。第二部分：显示了该类中所涉及到常量池，共35个常量。

第三部分：显示该类的构造器，编译器自动插入的。

第四部分：显示了main方的资讯。（这个是需要我们重点关注的）

2.2、常量池

官网文件：

https://docs.oracle.com/javase/specs/jvms/se8/html/jvms-4.html#jvms-4.4-140

Constant Type Value 说明

CONSTANT_Class 7 类或界面的符号引用

CONSTANT_Fieldref 9 字段的符号引用

CONSTANT_Methodref 10 类中方法的符号引用

CONSTANT_InterfaceMethodref 11 界面中方法的符号引用

CONSTANT_String 8 字串型别常量

CONSTANT_Integer 3 整形常量

CONSTANT_Float 4 浮点型常量

CONSTANT_Long 5 长整型常量

CONSTANT_Double 6 双精度浮点型常量

CONSTANT_NameAndType 12 字段或方法的符号引用

CONSTANT_Utf8 1 UTF-8编码的字串

CONSTANT_MethodHandle 15 表示方法控制代码

CONSTANT_MethodType 16 标志方法型别

CONSTANT_InvokeDynamic 18 表示一个动态方法呼叫点

2.3、描述符

2.3.1、字段描述符

官网：https://docs.oracle.com/javase/specs/jvms/se8/html/jvms-4.html#jvms-4.3.2

FieldType term

Type

Interpretation

B byte signed byte

C

char Unicode character code point in the Basic Multilingual Plane, encoded with UTF-16

D double double-precision floating-point value

F float single-precision floating-point value

I int integer

J long long integer

LClassName; reference an instance of class ClassName

S short signed short

Z boolean true or false

[ reference one array dimension

2.3.2、方法描述符

官网：https://docs.oracle.com/javase/specs/jvms/se8/html/jvms-4.html#jvms-4.3.3

示例：

The method descriptor for the method:

Object m(int i, double d, Thread t) {...}

is:

(IDLjava/lang/Thread;)Ljava/lang/Object;

2.4、解读方法字节码

public static void main(java.lang.String[]);

descriptor: ([Ljava/lang/String;)V //方法描述，V表示该方法的放回值为void

flags: ACC_PUBLIC, ACC_STATIC // 方法修饰符，public、static的

Code:

// stack=2,操作栈的大小为2、locals=4，本地变量表大小，args_size=1, 引数

的个数

stack=2, locals=4, args_size=1

0: iconst_2 //将数字2值压入操作栈，位于栈的最上面

1: istore_1 //从操作栈中弹出一个元素(数字2)，放入到本地变量表中，位

于下标为1的位置（下标为0的是this）

2: iconst_5 //将数字5值压入操作栈，位于栈的最上面

3: istore_2 //从操作栈中弹出一个元素(5)，放入到本地变量表中，位于第下标为2个位置

4: iload_2 //将本地变量表中下标为2的位置元素压入操作栈（5）

5: iload_1 //将本地变量表中下标为1的位置元素压入操作栈（2）

6: isub //操作栈中的2个数字相减

7: istore_3 // 将相减的结果压入到本地本地变量表中，位于下标为3的位置

// 通过#2号找到对应的常量，即可找到对应的引用

8: getstatic #2 // Field java/lang/System.out:Ljava/io/PrintStream;

11: iload_3 //将本地变量表中下标为3的位置元素压入操作栈（3）

// 通过#3号找到对应的常量，即可找到对应的引用，进行方法呼叫

12: invokevirtual #3 // Method java/io/PrintStream.println:(I)V

15: return //返回

LineNumberTable: //行号的列表

line 6: 0

line 7: 2

line 8: 4

line 9: 8

line 10: 15 LocalVariableTable: // 本地变量表

Start

0 Length

16 Slot

0 Name

args Signature

[Ljava/lang/String;

2 14 1 a I

4 12 2 b I

8 8 3 c I

}

SourceFile: Test1.java

2.4.1、图解

2.5、研究 i++ 与 ++i 的不同

我们都知道，i++表示，先返回再+1，++i表示，先+1再返回。它的底层是怎么样的呢? 我们一起探究下。

编写测试程式码：

public class Test2 {

public static void main(String[] args) {

new Test2().method1();

new Test2().method2();

}

public void method1(){

int i = 1; int a = i++;

System.out.println(a); //打印1

}

public void method2(){

int i = 1; int a = ++i;

System.out.println(a);//打印2

}

}

2.5.1、检视class字节码

Classfile /F:/code/itcast‐jvm/itcast‐jvm‐ test/target/classes/cn/itcast/jvm/Test2.class

MD5 checksum 901660fc11c43b6daadd0942150960ed Compiled from Test2.java

public class cn.itcast.jvm.Test2 minor version: 0

major version: 52

flags: ACC_PUBLIC, ACC_SUPER

Constant pool:

#1 = Methodref #8.#27 // java/lang/Object.: ()V

#2 = Class #28 // cn/itcast/jvm/Test2

#3 = Methodref #2.#27 // cn/itcast/jvm/Test2.

:()V

#4 = Methodref #2.#29 // cn/itcast/jvm/Test2.method1: ()V

#5 = Methodref #2.#30 // cn/itcast/jvm/Test2.method2: ()V

#6 = Fieldref #31.#32 // java/lang/System.out:Ljava/io/PrintStream;

#7 = Methodref #33.#34 // java/io/PrintStream.println: (I)V

#26 = Utf8 Test2.java

#27 = NameAndType #9:#10 // :()V

#28 = Utf8 cn/itcast/jvm/Test2

#29 = NameAndType #20:#10 // method1:()V

#30 = NameAndType #24:#10 // method2:()V

#31 = Class #36 // java/lang/System

#32 = NameAndType #37:#38 // out:Ljava/io/PrintStream;

#33 = Class #39 // java/io/PrintStream

#34 = NameAndType #40:#41 // println:(I)V

#35 = Utf8 java/lang/Object

#36 = Utf8 java/lang/System

#37 = Utf8 out

#38 = Utf8 Ljava/io/PrintStream;

#39 = Utf8 java/io/PrintStream

#40 = Utf8 println

#41 = Utf8 (I)V

{

public cn.itcast.jvm.Test2(); descriptor: ()V

flags: ACC_PUBLIC Code:

stack=1, locals=1, args_size=1 0: aload_0

1: invokespecial #1 // Method java/lang/Object.:()V

4: return LineNumberTable:

line 3: 0 LocalVariableTable:

Start Length Slot Name Signature

0 5 0 this Lcn/itcast/jvm/Test2;

public static void main(java.lang.String[]); descriptor: ([Ljava/lang/String;)V

flags: ACC_PUBLIC, ACC_STATIC

Code:

stack=2, locals=1, args_size=1

0: new #2 // class cn/itcast/jvm/Test2

3: dup

4: invokespecial #3 // Method :()V

7: invokevirtual #4 // Method method1:()V

10: new #2 // class cn/itcast/jvm/Test2

13: dup

14: invokespecial #3 // Method :()V

17: invokevirtual #5 // Method method2:()V

20: return LineNumberTable:

line 6: 0

line 7: 10

line 8: 20 LocalVariableTable:

Start Length Slot Name Signature

0 21 0 args [Ljava/lang/String;

public void method1(); descriptor: ()V flags: ACC_PUBLIC Code:

stack=2, locals=3, args_size=1 0: iconst_1

1: istore_1

2: iload_1

3: iinc 1, 1

6: istore_2

7: getstatic #6 // Field java/lang/System.out:Ljava/io/PrintStream;

10: iload_2

11: invokevirtual #7 // Method java/io/PrintStream.println:(I)V

14: return LineNumberTable:

line 11: 0

line 12: 2

line 13: 7

line 14: 14 LocalVariableTable:

Start Length Slot Name Signature

0 15 0 this Lcn/itcast/jvm/Test2; 2 13 1 i I

7 8 2 a I

public void method2(); descriptor: ()V flags: ACC_PUBLIC Code:

stack=2, locals=3, args_size=1 0: iconst_1

1: istore_1

2: iinc 1, 1

5: iload_1

6: istore_2

7: getstatic #6 // Field java/lang/System.out:Ljava/io/PrintStream;

10: iload_2

11: invokevirtual #7 // Method java/io/PrintStream.println:(I)V

14: return LineNumberTable:

line 17: 0

line 18: 2

line 19: 7

line 20: 14 LocalVariableTable:

Start Length Slot Name Signature

0 15 0 this Lcn/itcast/jvm/Test2; 2 13 1 i I

7 8 2 a I

}

SourceFile: Test2.java

2.5.2、对比

i++：

0: iconst_1 //将数字1压入到操作栈

1: istore_1 //将数字1从操作栈弹出，压入到本地变量表中，下标为1

2: iload_1 //从本地变量表中获取下标为1的资料，压入到操作栈中

3: iinc 1, 1 // 将本地变数中的1，再+1

6: istore_2 // 将数字1从操作栈弹出，压入到本地变量表中，下标为2 7: getstatic #6 // Field

java/lang/System.out:Ljava/io/PrintStream;

10: iload_2 //从本地变量表中获取下标为2的资料，压入到操作栈中

11: invokevirtual #7 // Method java/io/PrintStream.println:(I)V

14: return

++i：

0: iconst_1 //将数字1压入到操作栈

1: istore_1 //将数字1从操作栈弹出，压入到本地变量表中，下标为1

2: iinc 1, 1// 将本地变数中的1，再+1

5: iload_1 //从本地变量表中获取下标为1的资料（2），压入到操作栈中

6: istore_2 //将数字2从操作栈弹出，压入到本地变量表中，下标为2

7: getstatic #6 // Field java/lang/System.out:Ljava/io/PrintStream;

10: iload_2 //从本地变量表中获取下标为2的资料（2），压入到操作栈中

11: invokevirtual #7 // Method java/io/PrintStream.println:(I)V

14: return

区别：

i++

只是在本地变数中对数字做了相加，并没有将资料压入到操作栈

将前面拿到的数字1，再次从操作栈中拿到，压入到本地变数中

++i

将本地变数中的数字做了相加，并且将资料压入到操作栈将操作栈中的资料，再次压入到本地变数中

小结：可以通过检视字节码的方式对程式码的底层做研究，探究其原理。

2.6、字串拼接

字串的拼接在开发过程中使用是非常频繁的，常用的方式有三种：

+号拼接： str+“456”

StringBuilder拼接

StringBuffer拼接

StringBuffer是保证执行绪安全的，效率是比较低的，我们更多的是使用场景是不会涉及到 执行绪安全的问题的，所以更多的时候会选择StringBuilder，效率会高一些。

那么，问题来了，StringBuilder和“+”号拼接，哪个效率高呢？接下来我们通过字节码的 方式进行探究。

首先，编写个示例：

package cn.itcast.jvm;

public class Test3 {

public static void main(String[] args) {

new Test3().m1();

new Test3().m2();

public void m1(){

String s1 = 123; String s2 = 456; String s3 = s1 + s2; System.out.println(s3);

}

public void m2(){

String s1 = 123; String s2 = 456;

StringBuilder sb = new StringBuilder(); sb.append(s1);

sb.append(s2);

String s3 = sb.toString(); System.out.println(s3);

}

}

}

从解字节码中可以看出，m1()方法源代码中是使用+号拼接，但是在字节码中也被编译成了

StringBuilder方式。

所以，可以得出结论，字串拼接，+号和StringBuilder是相等的，效率一样。

接下来，我们再看一个案例：

package cn.itcast.jvm; public class Test4 {

public static void main(String[] args) { new Test4().m1();

new Test4().m2();

}

public void m1(){ String str = ;

for (int i = 0; i }

System.out.println(str);

}

public void m2(){

StringBuilder sb = new StringBuilder(); for (int i = 0; i sb.append(i);

}

System.out.println(sb.toString());

}

}

m1() 与 m2() 哪个方法的效率高？ 依然是通过字节码的方式进行探究。

可以看到，m1()方法中的循环体内，每一次循环都会建立StringBuilder物件，效率低于

m2()方法。

2.7、小结

使用字节码的方式可以很好检视程式码底层的执行，从而可以看出哪些实现效率高，哪些 实现效率低。可以更好的对我们的程式码做优化。让程式执行效率更高。

3、程式码优化

3.1、尽可能使用区域性变数

呼叫方法时传递的引数以及在呼叫中建立的临时变数都储存在栈中速度较快，其他变 量，如静态变数、例项变数等，都在堆中建立，速度较慢。另外，栈中建立的变数，随 著方法的执行结束，这些内容就没了，不需要额外的垃圾回收。

3.2、尽量减少对变数的重复计算

明确一个概念，对方法的呼叫，即使方法中只有一句语句，也是有消耗的。所以例如下 面的操作：

for (int i = 0; i {...}

建议替换为：

int length = list.size();

for (int i = 0,i

{...}

这样，在list.size()很大的时候，就减少了很多的消耗。

3.3、尽量采用懒载入的策略，即在需要的时候才建立

String str = aaa;

if (i == 1){

list.add(str);

}

//建议替换成

if (i == 1){

String str = aaa; list.add(str);

}

3.4、异常不应该用来控制程式流程

异常对效能不利。丢掷异常首先要建立一个新的物件，Throwable界面的建构函式呼叫 名为fillInStackTrace()的本地同步方 法，fillInStackTrace()方法检查堆叠，收集呼叫跟踪资讯。只要有异常被丢掷，Java虚拟机器就必须调整呼叫堆叠，因为在处理过程中建立 了一个新的物件。异常只能用于错误处理，不应该用来控制程式流程。

3.5、不要将阵列宣告为public static final

因为这毫无意义，这样只是定义了引用为static final，阵列的内容还是可以随意改变的， 将阵列宣告为public更是一个安全漏洞，这意味着这个阵列可以被外部类所改变。

3.6、不要建立一些不使用的物件，不要汇入一些不使用的类

这毫无意义，如果程式码中出现The value of the local variable i is not used、“The import java.util is never used”，那么请删除这些无用的内容

3.7、程式执行过程中避免使用反射

反射是Java提供给使用者一个很强大的功能，功能强大往往意味着效率不高。不建议在程式执行过程中使用尤其是频繁使用反射机制，特别是 Method的invoke方法。

如果确实有必要，一种建议性的做法是将那些需要通过反射载入的类在专案启动的时候 通过反射例项化出一个物件并放入内存。

3.8、使用数据库连线池和执行绪池

这两个池都是用于重用物件的，前者可以避免频繁地开启和关闭连线，后者可以避免频 繁地建立和销毁执行绪。

3.9、容器初始化时尽可能指定长度

容器初始化时尽可能指定长度，如：new ArrayList(10); new HashMap(32); 避免容器长度不足时，扩容带来的效能损耗。

3.10、ArrayList随机遍历快，LinkedList新增删除快

3.11、使用Entry遍历Map

Map map = new HashMap();

for (Map.Entry entry : map.entrySet()) { String key = entry.getKey();

String value = entry.getValue();

}

避免使用这种方式：

Map map = new HashMap(); for (String key : map.keySet()) {

String value = map.get(key);

}

3.12、不要手动呼叫System.gc();

3.13、String尽量少用正则表示式

正则表示式虽然功能强大，但是其效率较低，除非是有需要，否则尽可能少用。

replace() 不支援正则

replaceAll() 支援正则

如果仅仅是字元的替换建议使用replace()。

3.14、日志的输出要注意级别

// 当 前 的 日 志 级 别 是 error LOGGER.info(储存出错！ + user);

3.15、对资源的close()建议分开操作

try{

XXX.close();

YYY.close();

}

catch (Exception e){

...

}

// 建议改为

try{

XXX.close();

}

catch (Exception e){

...

}

try{

YYY.close();

}

catch (Exception e){

...

}