BO性能优化及小技巧
一、DS多个表和QUERRY做JOIN时性能处理
在Data Services 里，经常会遇到多个表做join或多个QUERRY做join的情况，如果数据量大的话，经常会耗费掉大量的时间。本文档主要解决此问题。
1、在R3里面，多个表做JOIN时。
性能的解决方法主要有两种：
①对参与JOIN的数据库表设优先级，优先级的高低由限制条件来决定。
如下例：
A表：200W数据量，有条件可以限制到10W
B表：200W数据量，有条件可以限制到50W
C表：200W数据量，没有条件限制
解决方案：这样如果A、B、C三个表做JOIN时，就可以把A表的优先级设为100,B 表设为95,C表设为90。（优先级的设置是相对的）
②可以先JOIN一部分表，然后把结果再与剩下的表做JOIN（即拆分）。
如下例：
条件依然和上面的一样。
解决方案：我们可以把A表与B表做JOIN，得到QUERRY1,然后把QUERRY1与表C 做JOIN。同时，我们依然可以设置优先级。
优先级设置位置如下图：
2、在R3外面，有两种情况，一种是多个QUERRY做JOIN，另一种是QUERRY与
数据库表做JOIN。
解决方案：有QUERRY做JOIN时，我们都需要先进行Data_Transfer（以下简称DT）转换，然后再参与JOIN。
DT需要设置两个地方。
①需要转换成临时表。如下图：
②需要设置同一时间处理的最大条目数及方式。如下图：
二、DS删除主键重复方法
由于核心类中，类与类之间存在各种关联关系，如一对多或者多对多的情况等。对于这样的情况，从SAP表中取出记录后，生成主键（流水号）时就会造成name以及mrid字段重复，这样在把流水号以及mrid字段插入map表中时，数据冗余。因此，对于这种情况，要把那些重复name字段的记录分组生成主键（流水号）。
1.解决方案
将关联关系导致主键重复的记录，按照需要后面用来生成主键流水号的字段A（如name 字段）排序，然后引用函数gen_row_num_by_group（A）对字段分组生成流水号，最后选取每组中的流水号为1的记录，这样就可以删除那些重复的记录，不会出现相同的name对应多个流水号的情况。
例子可以参考客户协议类：
、
2.注意事项
在筛选之前一定要排序，这个有点像abap里面对内表中相同的记录删除时要对内表进行排序
三、DS中文字符长度处理
1.需求说明
DataServices里面,其中文字符的格式与SAP的R3,Oracle数据库中文格式表示不一样,所以引起程序运行时出错,此文档解决了这个错误。
2.解决方案
DataServices如果出现如下错误提示:
图1
其解决方法如下图:就直接将拖过来的字段将Varchar类型的长度X2,这样就解决上述问题了.
图2
（图中Merge5处数据源是比较少出现的情况）
3.注意事项
3.1、上述做法最好在R3DF里面就做好。
只要程序出了R3DF后没有转换过来的中文格式,都会出现上图1的错误。
四、DS带小数位的数据类型乘以小数的问题
1.需求说明
在统计类上传中有一些电费是按照电量乘以一个比例而得到的，这时就要乘以一个小数位,本文档主要概述此问题以及解决办法。
2.问题现象
在统计类DF01用售电量乘以0.001 .
TOTAL_POWER的数据情况,可以看到sanxia_fee 都为0
3.测试及解决办法
3.1、更改query 的total_power 的字段类型为decimal(16,4)
可以看到sanxia_fee 的118.90
3.2、更改query 的total_power字段类型为int 后
可以看到sanxia_fee 的118.90
4.疑问
测试发现有时这个问题又不会发生,造成这个问题的真正原因是什么?
5.总结
在小数位乘以一个小数时要注意字段的类型，要检查生成的小数位是否正确。
五、DS使用Merge的注意事项
1.需求说明
DataServices里面,一个结果集的出来可能有多个来源,使用Merge可以将多个数据源处理成一个数据源已进行以后的处理。
2.解决方案
DataServices中提供了控件Merge用于合并多个数据源，直接拖放即可。（如图）
（图中Merge5处数据源是比较少出现的情况）
3.注意事项
3.1、多个数据源的字段个数,字段类型必须一致。
这是很明显的结果，Merge的用处是将多个数据源合并成一个数据源，而对数据本身没有任何处理，Merge后被认为是一个数据源交给以后的逻辑处理，如果之前的的字段属性不一致，那就无法确定Merge后的属性。
3.2、多个数据源的字段名称最好统一。
不统一时Merge会随机使用其中的名称作为自己的名称，造成之后的处理报错。
3.3、多个数据源的字段个数,字段类型必须一致。
Merge后直接连接DT时，需要注意字段映射关系。
Merge和Data transfer都是DS中常用的工具，本身都没有直接的字段属性，其属性都是由之前的数据源确认的，当Merge和Data transfer互联的时候，后者不能直接得到前者的字段属性（因为前者没有直接的字段属性）。这点在新的项目（比如刚刚从中央库下载得到）时特别明显，只需要鼠标点击前者，让前者获取字段属性即可。
Java堆是指在程序运行时分配给对象生存的空间。通过-mx/-Xmx和-ms/-Xms来设置起始堆的大小和最大堆的大小。根据自己JDK的版本和厂家决定使用-mx和-ms或-Xmx和-Xms。Java堆大小决定了垃圾回收的频度和速度，Java堆越大，垃圾回收的频度越低，速度越慢。同理，Java堆越小，垃圾回收的频度越高，速度越快。要想设置比较理想的参数，还是需要了解一些基础知识的。Java堆的最大值不能太大，这样会造成系统内存被频繁的交换和分页。所以最大内存必须低于物理内存减去其他应用程序和进程需要的内存。而且堆设置的太大，造成垃圾回收的时间过长，这样将得不偿失，极大的影响程序的性能。以下是一些经常使用的参数设置： 1) 设置-Xms等于-XmX的值； 2) 估计内存中存活对象所占的空间的大小，设置-Xms等于此值，-Xmx四倍于此值； 3) 设置-Xms等于-Xmx的1/2大小； 4) 设置-Xms介于-Xmx的1/10到1/4之间； 5) 使用默认的设置。 大家需要根据自己的运行程序的具体使用场景，来确定最适合自己的参数设置。除了-Xms和-Xmx两个最重要的参数外，还有很多可能会用到的参数，这些参数通常强烈的依赖于垃圾收集的算法，所以可能因为JDK的版本和厂家而有所不同。但这些参数一般在Web 开发中用的比较少，我就不做详细介绍了。在实际的应用中注意设置-Xms和-Xmx使其尽可能的优化应用程序就行了。对于性能要求很高的程序，就需要自己再多研究研究Java虚拟机和垃圾收集算法的机制了。可以看看曹晓钢翻译的《深入Java虚拟机》一书。 Java程序性能调优的基本知识和JDK 调优 一基本知识 1.1 性能是什么 在性能调优之前，我们首先来了解一下性能是什么？关于性能，我想每个学习过Java的人都能列 出几点，甚至可以夸夸其谈。在《Java TM Platform Performance》一书中，定义了如下五个方面来作 为评判性能的标准： 1) 运算的性能——哪一个算法的执行性能最好？ 2) 内存的分配——程序运行时需要耗费多少内存？
第一章 java 性能调优概述 1.1.2 性能的参考指标 1.2.1 设计调优 比如说如果A组件通过循环不断监控时间E是否发生，其必然会占用部分系统资源。但是可以通过observer模式解决： 1.2.2 代码调优 比如linkedList比ArrayList 随机访问性能好。 1.2.3 JVM调优 一般在开发后期做，比如内存结构，GC种类。 1.2.4 数据库调优 比如大量的拥有相同结构的SQL查询，可以用preparedStatement代替statement；指定要查询的列名，避免用“*”。 比如设置oracle的共享池、缓存区。 1 .2.5 操作系统调优 比如调整unix的共享内存值。
第二章设计优化 2.1 设计模式 2.1.1 单例模式 对于频繁使用对象，因为new次数少，对内存使用不频繁，将减轻GC压力。 2.1.2 代理模式 可以实现比如延迟加载 2.1.3 享元模式 好处同单例模式 2.1.5 观察者模式 可以代替多线程。 2.1.6 Value Object 一次封装所有的属性值，省得一次次请求属性值。 2.1.7 Business Delegate 代理类中一组远程方法调用构成一个业务流程，客户端调用代理类。 2.2 常用优化组件 2.2.1 缓冲 缓冲是一块内存区域，目的是缓解应用程序上下层之间的性能差异。 2.2.2 缓存 也是一块内存区域，目的是暂存数据处理结构，并供下次访问使用。 也可用ehCache等框架 2.2.3 对象复用池 比如线程池和数据库连接池
2.2.4 多线程 2.2.5 负载均衡 2.2.6 时间换空间 比如少申请变量 2.2.7 空间换时间 比如用缓存 第三章 java 程序优化 3.3 使用NIO提升性能 NIO为所有的原始类型提供buffer，NIO是基于Block的，NIO最重要的组件是buffer和Channel。 buffer是一个连续的内存快，是NIO读写数据的中转池。通道表示缓冲数据的源头或者目的地，它是用于想缓存读取或写入数据，是访问缓冲的接口。 3.4 使用软引用和弱引用 3.5 有利于改善性能的技巧 3.5.1 慎用异常 3.5.2 使用局部变量，因为局部变量是在stack中，比较快。 3.5.3 位运算代替乘除法 3.5.12 静态方法代替实例方法 第四章并行程序优化 4.5 锁的优化 4.5.7 ReentrantLock 重入锁 4.5.9 自旋锁
面向对象 构造器参数太多怎么办？ 用builder模式，用在 1、5个或者5个以上的成员变量 2、参数不多，但是在未来，参数会增加 Builder模式： 属于对象的创建模式，一般有 1.抽象建造者：一般来说是个接口，包含1）建造方法，建造部件的方法（不止一 个），2）返回产品的方法 2.具体建造者 3.导演者，调用具体的建造者，创建产品对象 4.产品，需要建造的复杂对象 对于客户端，创建导演者和具体建造者，并把具体建造者交给导演者，然后由客户端通知导演者操纵建造者进行产品的创建。 在实际的应用过程中，有时会省略抽象建造者和导演者。 不需要实例化的类应该构造器私有 如，一些工具类提供的都是静态方法，这些类是不应该提供具体的实例的。可以参考JDK 中的Arrays。 不要创建不必要的对象 1.避免无意中创建的对象，如自动装箱 2.可以在类的多个实例之间重用的成员变量，尽量使用static。
但是，要记住，是不要创建不必要的对象，而不是不要创建对象。 对象池要谨慎使用，除非创建的对象是非常昂贵的操作，如数据库的连接，巨型对象等等。 避免使用终结方法 finalizer方法，jdk不能保证何时执行，也不能保证一定会执行。如果有确实要释放的资源应该用try/finally。 使类和成员的可访问性最小化 编写程序和设计架构，最重要的目标之一就是模块之间的解耦。使类和成员的可访问性最小化无疑是有效的途径之一。 使可变性最小化 尽量使类不可变，不可变的类比可变的类更加易于设计、实现和使用，而且更不容易出错，更安全。 常用的手段： 不提供任何可以修改对象状态的方法； 使所有的域都是final的。 使所有的域都是私有的。 使用写时复制机制。带来的问题：会导致系统产生大量的对象，而且性能有一定的影响，需要在使用过程中小心权衡。 复合优先于继承 继承容易破坏封装性，而且会使子类的实现依赖于父类。 复合则是在类中增加一个私有域，引用类的一个实例，这样的话就避免了依赖类的具体实现。 只有在子类确实是父类的一个子类型时，才比较适合用继承。 接口优于抽象类 java是个单继承的，但是类允许实现多个接口。
1 数据库性能优化 ?优先考虑查询 数据库设计时，要优先考虑查询，因为在正常用户使用中，插入（insert）只有一次，但是会经常查询。例如在我们的OA中，起草一次，然后在接收端可能多个人要多次查询。 查询一般不要关联3个以上的表，也就是说一个业务的查询最多去关联3个表，如果必须要关联多个表，那么要尽可能的考虑怎么提高查询效率。 ?一定要考虑索引 在数据量很大的时候，一定要建立索引，索引虽说降低了插入和更新效率，但大大的提高了查询效率。在四川公文传输中通过建立索引，能 提升十几倍的效率。 ?分区 分区可以按照地域、时间等分区。我们现在的项目中主要是使用时间分区就可以了，分区可以避免查询时遍历很多条记录。 ?按新旧查询 这个也可以说是按照时间查询，例如：只查询半年内的数据，半年外的数据在另外一个功能模块中查询。这个主要是根据客户的使用习惯， 他们可能会经常查询半年之内的数据。这样避免每次都去遍历很多条记 录。 2 java性能优化 ?Hibernate缓存 Sprint和hibernate的结构现在是java开发的通用基本框架，所以不可能造成内存问题的，但现在网上也有人说hibernate内存有问题或则效率不高，这其实是没有真正掌握hibernate的技术。 Hibernate的缓存分为内在缓存、session缓存和查询缓存。可能和网上有些叫法不是很一样，道理都一样的。
内在缓存是hibernate的机制，当hibernate随着容器启动后，会把hibernate的pojo对象装载进入缓存中，这些是不能修改的。随着容器的关闭而自动释放。另外我们写的hql语言，hibernate会把这些编译成最低成的sql语句，也放在缓存中。这个也是随着容易的关闭而自动释放得。 Session缓存是随着session作用域的消失而消失，但通过在web.xml 中配置 openSessionInViewFilter，可以把session的作用域延长到jsp和action中。 查询缓存主要是用在更新很少，但查询很频繁的地方，提高查询效率和减少与数据库的交互。 Java内存 Java的内存分两部分： 持久化（perm）：这部分内存是装载进入jvm中是不会消失的，主要用在static中，还有例如：hibernate的hbm和pojo装载后都要把对象放在perm中。在第一次使用是装载近来，不会随着时间或并发量的变化而变化。 另一部分内存就是会随着使用的增加而增加，例如一个发文业务，并发100个人同时使用，那么就会执行100次装载，但这部分内存会随着使用的结束而释放。一般内存益处的问题都在这里，有些代码写的内存不会释放，还有代码写的过于消耗内存，造成并发很大时，内存还来不及释放已经把虚拟机内存撑暴。 Java虚拟机的内存在64位操作系统中可以无限开大，取决于硬件的内存配置。 Java虚拟机的内存在32位操作系统中只能开到1300M~1800M，取决于操作系统，一般linux操作系统可以比windows多开几百M。但可以使用垂直集群方法来解决这个问题，也就是在一台服务器上安装多个java容器。
Java程序性能优化方案 StringTokenizer比String.split()方法效率高 更优化的方式 Java代码 while(true){ String splitStr=null; int j=temp.indexOf(';'); if(j<0)break; SplitStr=tmp.substring(0,j); tmp=tmp.substring(j+1); } while(true){ String splitStr=null; int j=temp.indexOf(';'); if(j<0)break; SplitStr=tmp.substring(0,j); tmp=tmp.substring(j+1); } 比String.startsWith和endsWith性能更优的方式：Java代码 int len=orgStr.length(); if(orgStr.charAt(0)=='a' &&orgStr.charAt(1)=='b' &&orgStr.charAt(2)=='b'); if(orgStr.charAt(len-1)=='a' &&orgStr.charAt(len-2)=='b' &&orgStr.charAt(len-3)=='c');
int len=orgStr.length(); if(orgStr.charAt(0)=='a' &&orgStr.charAt(1)=='b' &&orgStr.charAt(2)=='b'); if(orgStr.charAt(len-1)=='a' &&orgStr.charAt(len-2)=='b' &&orgStr.charAt(len-3)=='c'); StringBuffer(int capacity)指定初始容量可以减少扩容的操作
Java程序性能优化 一、避免在循环条件中使用复杂表达式 在不做编译优化的情况下，在循环中，循环条件会被反复计算，如果不使用复杂表达式，而使循环条件值不变的话，程序将会运行的更快。 例子： import java.util.Vector; class CEL { void method (Vector vector) { for (int i = 0; i < vector.size (); i++) // Violation ; // ... } } 更正： class CEL_fixed { void method (Vector vector) { int size = vector.size () for (int i = 0; i < size; i++) ; // ... } } 二、为'Vectors' 和'Hashtables'定义初始大小 JVM为Vector扩充大小的时候需要重新创建一个更大的数组，将原原先数组中的内容复制过来，最后，原先的数组再被回收。可见Vector容量的扩大是一个颇费时间的事。 通常，默认的10个元素大小是不够的。你最好能准确的估计你所需要的最佳大小。 例子： import java.util.Vector; public class DIC { public void addObjects (Object[] o) { // if length > 10, Vector needs to expand for (int i = 0; i< o.length;i++) { v.add(o); // capacity before it can add more elements. } } public Vector v = new V ector(); // no initialCapacity. }
你是否正打算优化hashCode()方法？是否想要绕开正则表达式？Lukas Eder介绍了很多简单方便的性能优化小贴士以及扩展程序性能的技巧。 最近“全网域（Web Scale）”一词被炒得火热，人们也正在通过扩展他们的应用程序架构来使他们的系统变得更加“全网域”。但是究竟什么是全网域？或者说如何确保全网域？扩展的不同方面 全网域被炒作的最多的是扩展负载（Scaling load），比如支持单个用户访问的系统也可以支持10 个、100个、甚至100万个用户访问。在理想情况下，我们的系统应该保持尽可能的“无状态化（stateless）”。即使必须存在状态，也可以在网络的不同处理终端上转化并进行传输。当负载成为瓶颈时候，可能就不会出现延迟。所以对于单个请求来说，耗费50到100毫秒也是可以接受的。这就是所谓的横向扩展（Scaling out）。 扩展在全网域优化中的表现则完全不同，比如确保成功处理一条数据的算法也可成功处理10条、100条甚至100万条数据。无论这种度量类型是是否可行，事件复杂度（大O符号）是最佳描述。延迟是性能扩展杀手。你会想尽办法将所有的运算处理在同一台机器上进行。这就是所谓的纵向扩展（Scaling up）。 如果天上能掉馅饼的话（当然这是不可能的），我们或许能把横向扩展和纵向扩展组合起来。但是，今天我们只打算介绍下面几条提升效率的简单方法。 大O符号 Java 7的ForkJoinPool和Java8 的并行数据流（parallel Stream）都对并行处理有所帮助。当在多核处理器上部署Java程序时表现尤为明显，因所有的处理器都可以访问相同的内存。
JA V A WEB系统性能调优 V1.0 广州合道信息科技有限公司 2014年3月
?文档信息 项目名: 项目编号: 作者: 罗承伟 创建日期: 2014-03-21 使用者: 标题: Javaweb 系统性能调优方案 分类: 部门名称: 研发部 版权声明: ?文档状态 ?修订文档历史记录 初稿罗承伟
目录 1. 性能调优流程 (4) 1.1、确定调优目标 (4) 1.2、测量系统性能 (5) 1.3、分析性能瓶颈 (5) 2. JVM性能调优 (5) 2.1、JVM内存组成及分配 (6) 2.1.1、JA V A内存组成介绍:堆(Heap)和非堆(Non-heap)内存 (6) 2.1.2、堆内存分配 (6) 2.1.3、非堆内存分配 (7) 2.1.4、JVM内存限制(最大值) (8) 2.2、JVM参数详解 (8) 2.3、参数配置示例 (14) 3. J2EE应用监控 (15) 3.1、数据库连接池监控(Druid) (15) 3.1.1、Druid连接池配置 (15) 3.1.2、Druid连接池监控 (17) 3.2、容器管理及监控(psi-probe) (18) 3.2.1、Tomcat下安装部署 (18) 3.2.2、probe监控界面 (22) 3.3、JA V A虚拟机监控(Visual VM) (25) 3.3.1、VisualVM安装 (25) 3.3.2、VisualVM简介 (25) 3.3.3、安装插件 (26) 3.3.4、监控本地JA V A应用 (27) 3.3.5、监控远程JA V A应用 (28) 3.3.6、使用Visual VM查看JVM相关信息 (31) 3.3.7、使用Visual VM解决内存溢出问题 (33) 3.3.8、使用Visual VM查看Tomcat的线程状态 (34) 3.3.8、使用Visual VM查看CPU消耗情况 (36)
Java在九十年代中期出现以后，在赢得赞叹的同时，也引来了一些批评。赢得的赞叹主要是Java的跨平台的操作性，即所谓的”Write Once,Run Anywhere”.但由于Java的性能和运行效率同C相比，仍然有很大的差距，从而引来了很多的批评。 对于服务器端的应用程序，由于不大涉及到界面设计和程序的频繁重启，Java的性能问题看似不大明显，从而一些Java的技术，如JSP,Servlet,EJB等在服务器端编程方面得到了很大的应用，但实际上，Java的性能问题在服务器端依然存在。下面我将分四个方面来讨论Java的性能和执行效率以及提高Java 性能的一些方法。 一．关于性能的基本知识 1．性能的定义 在我们讨论怎样提高Java的性能之前，我们需要明白“性能“的真正含义。我们一般定义如下五个方面作为评判性能的标准。 1）运算的性能----哪一个算法的执行性能最好 2）内存的分配----程序需要分配多少内存，运行时的效率和性能最高。 3）启动的时间----程序启动需要多少时间。 4）程序的可伸缩性-----程序在用户负载过重的情况下的表现。 5）性能的认识------用户怎样才能认识到程序的性能。 对于不同的应用程序，对性能的要求也不同。例如，大部分的应用程序在启动时需要较长的时间，从而对启动时间的要求有所降低；服务器端的应用程序通常都分配有较大的内存空间，所以对内存的要求也有所降低。但是，这并不是所这两方面的性能可以被忽略。其次，算法的性能对于那些把商务逻辑运用到事务性操作的应用程序来讲非常重要。总的来讲，对应用程序的要求将决定对各个性能的优先级。 2．怎样才能提高JAVA的性能 提高JAVA的性能，一般考虑如下的四个主要方面： （1）程序设计的方法和模式 一个良好的设计能提高程序的性能，这一点不仅适用于JAVA，也适用也任何的编程语言。因为它充分利用了各种资源，如内存，CPU,高速缓存，对象缓冲池及多线程，从而设计出高性能和可伸缩性强的系统。
第1章Java性能调优概述 本章对性能优化技术进行整体性的介绍，让读者了解性能的概念和性能优化的基本思路与方法。掌握这些内容，有助于读者对性能问题进行系统性的分析。 本章涉及的主要知识点有： ?评价性能的主要指标； ?木桶原理的概念及其在性能优化中的应用； ?Amdahl定律的含义； ?性能调优的层次； ?系统优化的一般步骤和注意事项。 1.1 性能概述 为什么程序总是那么慢？它现在到底在干什么？时间都花到哪里去了？也许，你经常会抱怨这些问题。如果是这样，那说明你的程序出了性能问题。和功能性问题相比，性能问题在有些情况下，可能并不算什么太大的问题，将就将就，也就过去了。但是，严重的性能问题会导致程序瘫痪、假死，直至奔溃。本节就先来认识性能的各种表现和指标。 1.1.1 看懂程序的性能 对客户端程序而言，拙劣的性能会严重影响用户体验。界面停顿、抖动、响应迟钝等问题会遭到用户不停的抱怨。一个典型的例子就是Eclipse IDE工具在Full GC时会出现程序假死现象，相信一定被不少开发人员所诟病。对于服务器程序来说，性能问题则更为重要，相信不少后台服务器软件都有各自的性能目标。以Web服务器为例，服务器的响应时间、吞吐量就是两个重要的性能参数。当服务器承受巨大的访问压力时，可能出现响应时间变长、吞吐量下降，甚至是抛出内存溢出异常而崩溃。这些问题，都是性能调优需要解决的。 一般来说，程序的性能通过以下几个方面来表现： ?执行速度：程序的反映是否迅速，响应时间是否足够短。 ?内存分配：内存分配是否合理，是否过多地消耗内存或者存在泄漏。 ?启动时间：程序从运行到可以正常处理业务需要花费多长时间。 ?负载承受能力：当系统压力上升时，系统的执行速度、响应时间的上升曲线是否平缓。
通过使用一些辅助性工具来找到程序中的瓶颈，然后就可以对瓶颈部分的代码进行优化。一般有两种方案：即优化代码或更改设计方法。我们一般会选择后者，因为不去调用以下代码要比调用一些优化的代码更能提高程序的性能。而一个设计良好的程序能够精简代码，从而提高性能。 下面将提供一些在JA V A程序的设计和编码中，为了能够提高JA V A程序的性能，而经常采用的一些方法和技巧。 1．对象的生成和大小的调整。 JA V A程序设计中一个普遍的问题就是没有好好的利用JA V A语言本身提供的函数，从而常常会生成大量的对象（或实例）。由于系统不仅要花时间生成对象，以后可能还需花时间对这些对象进行垃圾回收和处理。因此，生成过多的对象将会给程序的性能带来很大的影响。 例1：关于String ,StringBuffer，+和append JA V A语言提供了对于String类型变量的操作。但如果使用不当，会给程序的性能带来影响。如下面的语句： String name=new String("HuangWeiFeng"); System.out.println(name+"is my name"); 看似已经很精简了，其实并非如此。为了生成二进制的代码，要进行如下的步骤和操作： (1) 生成新的字符串new String（STR_1); (2) 复制该字符串; (3) 加载字符串常量"HuangWeiFeng"（STR_2); (4) 调用字符串的构架器（Constructor）; (5) 保存该字符串到数组中（从位置0开始）; (6) 从java.io.PrintStream类中得到静态的out变量; (7) 生成新的字符串缓冲变量new StringBuffer(STR_BUF_1); (8) 复制该字符串缓冲变量; (9) 调用字符串缓冲的构架器（Constructor）; (10) 保存该字符串缓冲到数组中（从位置1开始）; (11) 以STR_1为参数，调用字符串缓冲(StringBuffer)类中的append方法; (12) 加载字符串常量"is my name"(STR_3); (13) 以STR_3为参数，调用字符串缓冲(StringBuffer)类中的append方法; (14) 对于STR_BUF_1执行toString命令; (15) 调用out变量中的println方法，输出结果。 由此可以看出，这两行简单的代码，就生成了STR_1,STR_2,STR_3,STR_4和STR_BUF_1五个对象变量。这些生成的类的实例一般都存放在堆中。堆要对所有类的超类，类的实例进行初始化，同时还要调用类极其每个超类的构架器。而这些操作都是非常消耗系统资源的。因此，对对象的生成进行限制，是完全有必要的。
下面方法不能读大文件 Java中的IO的性能优化 在使用IO的时候注意一下细节，能使性能得到很大的优化. 首先读写大文件，使用Buffer是肯定的了,使用方法，有下边两个 1方法一： 2public static void test1(String fileName){ 3long start=System.currentTimeMillis(); 4try{ 5FileInputStream fis=new FileInputStream(fileName); 6BufferedReader br=new BufferedReader(new InputStreamReader(fis)); 7StringBuffer sb=new StringBuffer(); 8String str; 9while((str=br.readLine())!=null){ 10sb.append(str); 11} 12}catch(IOException e){ 13} 14long end=System.currentTimeMillis(); 15long time=end-start; 16System.out.println(time); 17} 18方法二： 19public static void test2(String fileName){ 20long start=System.currentTimeMillis(); 21try{ 22FileInputStream fis=new FileInputStream(fileName); 23byte buf[]=new byte[8192]; 24int n; 25StringBuffer sb=new StringBuffer(); 26while((n=fis.read(buf))!=-1){ 27sb.append(buf); 28} 29fis.close(); 30}catch(IOException e){ 31} 32long end=System.currentTimeMillis(); 33long time=end-start; 34System.out.println(time); 35} 方法一1937ms 方法二47ms
java系统优化以及代码优化方法 Java代码优化是Java编程开发很重要的一个步骤，Java代码优化要注重细节优化，一个两个的细节的优化，产生的效果不大，但是如果处处都能注意代码优化，对代码减少体积、提高代码运行效率是有巨大帮助的，还能在一定程度上避免未知错误，常用的Java代码优化细节如下： 1. 为类、方法指定final修饰符 为类指定final修饰符可以让类不可以被继承，为方法指定final修饰符可以让方法不可以被重写，如果指定了一个类为final，则该类所有的方法都是final的，Java编译器会寻找机会内联所有的final方法，内联对于提升Java 运行效率作用重大，能够使性能平均提高50%。 2. 尽量重用对象 由于Java虚拟机不仅要花时间生成对象，还需要花时间对这些对象进行垃圾回收和处理，因此，生成过多的对象将会给程序的性能带来很大的影响。 3. 尽可能使用局部变量 调用方法时传递的参数以及在调用中创建的临时变量都保存在栈中，速度较快，其他变量都在堆中创建，速度较慢，且栈中创建的变量，随着方法的运行结束，内容就没了，不要额外的垃圾回收。 4. 及时关闭流 Java编程过程中，进行数据库连接、I/O流操作时务必小心，在使用完毕后，及时关闭以释放资源，因为对这些大对象的操作会造成系统大的开销，稍有不慎，将会导致严重的后果。
5. 尽量减少对变量的重复计算 在方法调用中，即使方法只有一句语句，也是有消耗的，因此，在进行方法调用时尽可以减少对变量的重复定义和引用。 6. 尽量采用懒加载的策略，即在需要的时候才创建 7. 慎用异常 异常对性能不利，因为只要有异常被抛出，Java虚拟机就必须调整调用堆栈，异常只能用于错误处理，不应该用来控制程序流程。 8. 不要在循环中使用try…catch…，应该把其放在最外层 9. 如果能估计到待添加的内容长度，为底层以数组方式实现的集合、工具类指定初始长度 10. 当复制大量数据时，使用System.arraycopy()命令 11. 乘法和除法使用移位操作 用移位操作可以极大地提高性能，因为在计算机底层，对位的操作是最方便、最快的。 12. 循环内不要不断创建对象引用 13. 基于效率和类型检查的考虑，应该尽可能使用array，无法确定数组大小时才使用ArrayList。 14. 尽量使用HashMap、ArrayList、StringBuilder，除非线程安全需要，否则不推荐使用Hashtable、Vector、StringBuffer，后三者由于使用同步机制而导致了性能开销 15. 不要将数组声明为public static final 因为这毫无意义，这样只是定义了引用为static final，数组的内容还是
Java性能优化技巧集锦=================================== 提纲: =================================== 一、通用篇 1.1 不用new关键词创建类的实例 1.2 使用非阻塞 I/O 1.3 慎用异常 1.4 不要重复初始化变量 1.5 尽量指定类的final修饰符 1.6 尽量使用局部变量 1.7 乘法和除法 1.8 尽量重用对象。 二、J2EE篇 2.1 使用缓冲标记 2.2 始终通过会话Bean访问实体Bean 2.3 选择合适的引用机制 2.4 在部署描述器中设置只读属性 2.5 缓冲对EJB Home的访问 2.6 为EJB实现本地接口 2.7 生成主键 2.8 及时清除不再需要的会话 2.9 在JSP页面中关闭无用的会话 2.10 Servlet与存使用
2.11 HTTP Keep-Alive 2.12 JDBC与Unicode 2.13 JDBC与I/O 2.14 存数据库 三、GUI篇 3.1 用JAR压缩类文件 3.2 提示Applet装入进程 3.3 在画出图形之前预先装入它 3.4 覆盖update方法 3.5 延迟重画操作 3.6 使用双缓冲区 3.7 使用BufferedImage 3.8 使用VolatileImage 3.9 使用Window Blitting 四、JavaScript性能优化 1.使用局部变量避免使用全局变 2.避免使用with 3.遍历nodelist的方式 4.别用那么多个var，一个加逗号就搞定了 5.innerHTML是最好的选择 6.ie的removeChild不好用 7.为多个同级元素绑定事件时，不用为每个都绑定，为他们的父级绑定就行了 8.尽量用原生的方法，因为原生的都是用c/c++编译而成的他们执行的要比用js写 的方法快多了 9.appendChild用的多时一定要用docuemntfragment 10.if else用的>=3个了，那用switch吧，好阅读，性能好 11.if<=3,别用if了，用3元表达式吧 12.if==1，if改&& 13.元素位置，while()offsetParent 14.正则的查找没有indexOf快
2019年JAVA代码性能效率优化28个方法 最近在想自己编程时是否注意过代码的效率问题，得出的答案是：没有。代码只是实现了功能，至于效率高不高没怎么关注，这应该是JAVA程序员进阶的时候需要考虑的问题，不再是单纯的实现功能，也不是完全依赖GC而不关注内存中发生了什么，而要考虑到代码的性能。下面是网上找的一篇关于JAVA代码优化的文章，觉得不错，就转载了。这里面设计到了JAVA基础和J2EE方面的优化建议，有时间会整理一下，现在先转载。 1、尽量指定类的final修饰符带有final修饰符的类是不可派生的。 如果指定一个类为final，则该类所有的方法都是final。Java编译器会寻找机会内联（inline）所有的final方法（这和具体的编译器实现有关）。此举能够使性能平均提高50% 。 2、尽量重用对象。 特别是String 对象的使用中，出现字符串连接情况时应用StringBuffer 代替。由于系统不仅要花时间生成对象，以后可能还需花时间对这些对象进行垃圾回收和处理。因此，生成过多的对象将会给程序的性能带来很大的影响。 3、尽量使用局部变量，调用方法时传递的参数以及在调用中创建的临时变量都保存在栈（Stack）中，速度较快。 其他变量，如静态变量、实例变量等，都在堆（Heap）中创建，速度较慢。另外，依赖于具体的编译器/JVM，局部变量还可能得到进一步优化。
4、不要重复初始化变量 默认情况下，调用类的构造函数时，Java会把变量初始化成确定的值：所有的对象被设置成null，整数变量（byte、short、int、long）设置成0，float和double变量设置成0.0，逻辑值设置成false。当一个类从另一个类派生时，这一点尤其应该注意，因为用new关键词创建一个对象时，构造函数链中的所有构造函数都会被自动调用。 5、在JAVA + ORACLE 的应用系统开发中，java中内嵌的SQL语句尽量使用大写的形式，以减轻ORACLE解析器的解析负担。 6、I/O操作中需要及时释放资源 Java 编程过程中，进行数据库连接、I/O流操作时务必小心，在使用完毕后，即使关闭以释放资源。 因为对这些大对象的操作会造成系统大的开销，稍有不慎，会导致严重的后果。 7、保证过期对象的及时回收 由于JVM的有其自身的GC机制，不需要程序开发者的过多考虑，从一定程度上减轻了开发者负担，但同时也遗漏了隐患，过分的创建对象会消耗系统的大量内存，严重时会导致内存泄露，因此，保证过期对象的及时回收具有重要意义。 JVM回收垃圾的条件是：对象不在被引用；然而，JVM的GC并非十分的机智，即使对象满足了垃圾回收的条件也不一定会被立即回收。所以，建议我们在对象使用完毕，应手动置
分享Java内存优化的几个小技巧 有的人觉得Java已经隐没在其他计算机语言的大潮中了，其实不然，我们日常用的软件、银行的系统、游戏等都是有Java的功劳的。理论上来讲Java系统并不会比其他语言系统更占用内存，但是为什么它确实占内存呢?两个字，陋习。下文我就讲讲那些日常编写中的坏习惯。 首先来了解java是如何管理内存的呢? Java的内存管理就是对象的分配和释放问题。 分配：内存的分配是由程序完成的，程序员需要通过关键字new为每个对象申请内存空间(基本类型除外)，所有的对象都在堆(Heap)中分配空间。 释放：对象的释放是由垃圾回收机制决定和执行的，这样做确实简化了程序员的工作。但同时，它也加重了JVM的工作。因为，GC为了能够正确释放对象，GC必须监控每一个对象的运行状态，包括对象的申请、引用、被引用、赋值等，GC都需要进行监控。 1、变量只有在用到它的时候才定义和实例化。 2、尽量少用finalize函数，因为finalize()会加大GC的工作量，而GC相当于耗费系统的计算能力。 3、用StrurringBuffer代替字符串相加 4、保证每个IO操作，connection及时关闭 5、别用New Integer 和Boolean类似，java开发中使用Integer封装int的场合也非常多，并且通常用int 表示的数值通常都非常小。SUN SDK中对Integer的实例化进行了优化，Integer类缓存了-128到127这256个状态的Integer，如果使用Integer.valueOf(int i)，传入的int 范围正好在此内，就返回静态实例。这样如果我们使用Integer.valueOf代替new Integer 的话也将大大降低内存的占用。如果你的系统要在不同的SDK(比如IBM SDK)中使用的话，那么可以自己做了工具类封装，比如IntegerUtils.valueOf()，这样就可以在任何SDK中都可以使用这种特性。 6、尽量在合适的场景下使用对象池技术以提高系统性能，缩减缩减开销，但是要注意对象池的尺寸不宜过大，及时清除无效对象释放内存资源，综合考虑应用运行环境的内存资源限制，避免过高估计运行环境所提供内存资源的数量。 7、对频繁使用的对象采用对象池技术。 8、避免过深的类层次结构和过深的方法调用 9、尽量避免在类的构造函数里创建、初始化大量的对象，防止在调用其自身类的构造器时造成不必要的内存资源浪费，尤其是大对象，JVM会突然需要大量内存，这时必然会触发GC优化系统内存环境;显示的声明数组空间，而且申请数量还极大。 10、尽量少用静态变量，因为静态变量是全局的，GC不会回收的
Java Web 服务性能优化案例 简介：本文介绍如何提升Java Web 服务性能，主要介绍了三种方法：一是采用 Web 服务的异步调用，二是引入Web 服务批处理模式，三是压缩SOAP 消息。重点介绍在编程过程中如何使用异步Web 服务以及异步调用和同步调用的差异点。本文还示范了如何在项目中使用以上三种方法，以及各种方法所适合的应用场景。 Java Web 服务简介 Web 服务是一种面向服务架构的技术，通过标准的 Web 协议提供服务，目的是保证不同平台的应用服务可以互操作。Web 服务（Web Service）是基于XML 和HTTP 通讯的一种服务，其通信协议主要基于SOAP，服务的描述通过WSDL、UDDI 来发现和获得服务的元数据。这种建立在XML 标准和Internet 协议基础上的Web 服务是分布式计算的下一步发展方向，Web 服务为那些由不同资源构建的商业应用程序之间的通信和协作带来了光明的前景，从而使它们可以彼此协作，而不受各自底层实现方案的影响。 JAX-RPC 1.0 是Java 方面的Web 服务的原始标准, 但是由于JAX-RPC 1.0 对Web 服务功能的认识有一定的局限，于是JAX-WS 2.0 应用而生。JAX-WS 2.0 开发工作的主要目标是对各项标准进行更新，成功实现了业界对JAX-RPC 1.X 的各种期望。此外，JAX-WS 2.0 直接支持XOP/MTOM，提高了系统附件传送能力以及系统之间的互操作性。 实例剖析Web 服务性能瓶颈 通过以上简述不难体会到，Web 服务以其XML + HTTP 的松耦合、平台无关的特性，集万般宠爱于一身，必将成为未来数据共享的基础。但与此同时我们也应当认识到世间完事万物均有其矛盾的两面性：有优点，必将存在缺点，Web 服务亦是如此。就像当初JAVA 大行其道的时候性能成为其致命诟病一样，Web 服务也同样面临性能问题，似乎“性能问题”天生就是“平台无关”挥之不去的冤家。但问题终归要解决，实践是检验和分析问题的唯一途径，让我们先来创建一个简单的Web 服务再来审视和分析隐含其中的性能问题。 创建服务 创建服务Java Bean: 首先我们创建一个尽可能简单的书店服务Bean，服务的内容只有一个qryBooksByAuthor，即根据作者(Author) 查询其名下的书籍 (List
大多数开发人员理所当然地以为性能优化很复杂，需要大量的经验和知识。好吧，不能说这是完全错误的。优化应用程序以获得最佳性能不是一件容易的事情。但是，这并不意味着如果你不具备这些知识，就不能做任何事情。这里有11个易于遵循的建议和最佳实践可以帮助你创建一个性能良好的应用程序。 大部分建议是针对Java的。但也有若干建议是与语言无关的，可以应用于所有应用程序和编程语言。在讨论专门针对Java的性能调优技巧之前，让我们先来看看通用技巧。 1.在你知道必要之前不要优化 这可能是最重要的性能调整技巧之一。你应该遵循常见的最佳实践做法并尝试高效地实现用例。但是，这并不意味着在你证明必要之前，你应该更换任何标准库或构建复杂的优化。 在大多数情况下，过早优化不但会占用大量时间，而且会使代码变得难以阅读和维护。更糟糕的是，这些优化通常不会带来任何好处，因为你花费大量时间来优化的是应用程序的非关键部分。 那么，你如何证明你需要优化一些东西呢？ 首先，你需要定义应用程序代码的速度得多快，例如，为所有API调用指定最大响应时间，或者指定在特定时间范围内要导入的记录数量。在完成这些之后，你就可以测量应用程序的哪些部分太慢需要改进。然后，接着看第二个技巧。 2.使用分析器查找真正的瓶颈 在你遵循第一个建议并确定了应用程序的某些部分需要改进后，那么从哪里开始呢？ 你可以用两种方法来解决问题： 1、查看你的代码，并从看起来可疑或者你觉得可能会产生问题的部分开始。 2、使用分析器并获取有关代码每个部分的行为和性能的详细信息。 希望不需要我解释为什么应该始终遵循第二种方法的原因。 很明显，基于分析器的方法可以让你更好地理解代码的性能影响，并使你能够专注于最关键的部分。如果你曾使用过分析器，那么你一定记得曾经你是多么惊讶于一下就找到了代码的哪些部分产生了性能问题。老实说，我第一次的猜测不止一次地导致我走错了方向。 3.为整个应用程序创建性能测试套件
1.你怎样给tomcat去调优? 1. JVM参数调优：-Xms