「java性能计数」java性能提升
今天给各位分享java性能计数的知识，其中也会对java性能提升进行解释，如果能碰巧解决你现在面临的问题，别忘了关注本站，现在开始吧！
本文目录一览：
- 1、Java性能如何优化?
- 2、Java几款性能分析工具的对比
- 3、如何优化java程序设计和编码,提高java性能
- 4、Java反射的性能为什么比直接调用慢一个数量级左右
- 5、怎么做JAVA程序性能优化
Java性能如何优化?
代码优化细节
1、尽量指定类、方法的final修饰符
带有final修饰符的类是不可派生的。在Java核心API中，有许多应用final的例子，例如java.lang.String，整个类都是final的。为类指定final修饰符可以让类不可以被继承，为方法指定final修饰符可以让方法不可以被重写。
如果指定了一个类为final，则该类所有的方法都是final的。Java编译器会寻找机会内联所有的final方法，内联对于提升Java运行效率作用重大，具体参见Java运行期优化。此举能够使性能平均提高50%。
2、尽量重用对象
特别是String对象的使用，出现字符串连接时应该使用StringBuilder/StringBuffer代替。由于Java虚拟机不仅要花时间生成对象，以后可能还需要花时间对这些对象进行垃圾回收和处理，因此，生成过多的对象将会给程序的性能带来很大的影响。
3、尽可能使用局部变量
调用方法时传递的参数以及在调用中创建的临时变量都保存在栈中，速度较快，其他变量，如静态变量、实例变量等，都在堆中创建，速度较慢。另外，栈中创建的变量，随着方法的运行结束，这些内容就没了，不需要额外的垃圾回收。
4、及时关闭流
Java编程过程中，进行数据库连接、I/O流操作时务必小心，在使用完毕后，及时关闭以释放资源。因为对这些大对象的操作会造成系统大的开销，稍有不慎，将会导致严重的后果。
5、尽量减少对变量的重复计算
明确一个概念，对方法的调用，即使方法中只有一句语句，也是有消耗的，包括创建栈帧、调用方法时保护现场、调用方法完毕时恢复现场等。所以例如下面的操作：
for (int i = 0; i list.size(); i++)
{...}
建议替换为：
for (int i = 0, length = list.size(); i length; i++)
{...}
这样，在list.size()很大的时候，就减少了很多的消耗
Java几款性能分析工具的对比
1、VisualVM
VisualVM是一个资源分析工具，一直从JDK 6更新到7。它默认内存和CPU的监视。它可以告诉你哪个类和方法消耗资源，但它不会显示代码流程。
2、JProfiler
JProfiler很容易安装，并且通过向导，你可以选择应用服务器用来运行应用程序。我不得不选择使用JPofiler应用服务器的主目录，以及向导生成的一个单独的启动脚本。然后运行服务器。在监听会话的过程中，它会提供了几个选项。它可以记录内存的使用和CPU的使用率。在查看CPU的使用率同时，可以看到执行路径。这让我看到应用程序大部分时间都花在请求上。我们可以将IntelliJ插件安装到IDE上，那么运行JProfiler会更加便利。比如，可以直接帮我启动Tomcat。
3、YourKit
YourKit是我在另一个项目中偶然发现的一款性能分析工具。它的安装很简单。安装时有一个选项，可以安装一个插件到我的IDE。安装后，运行应用程序，使用该插件，它会自动连接到YourKit。它有一个漂亮的用户界面可以查看到内存和CPU的监测，同时也可以看到请求的执行路径。
4、JProbe
我刚开始创建JProbe时遇到点困难。安装并不是直接完成，我需要对它进行配置。它采用了类似JProfiler一样的设置。它会在你的Tomcat目录中生成启动脚本。可以通过脚本启动服务器并监听会话。它的界面包含有按钮和表格，其中可以看到内存的使用，但无法在进程中找到执行路径。
5、Spring Insight
听到TC Server有Spring Insight监控界面，于是我兴奋地尝试了一下。安装完成后，并设置成TC Server的开发者版，然后部署应用程序在TC Server上。我查看Insight界面，它可以很好的监视类和方法，并能看到完成这个方法用了多少时间。我还能看到输入参数值，以及返回值。由于我的应用程序是基于Spring的，Spring Insight能够提供非常有用的数据。TC Server插件在IDE上的配置与Tomcat的配置类似。SpringSource工具套件就自带Spring Insight。
结论
看到这五款性能分析工具，我可以肯定地说，它们都非常不错。如果你有基于Spring的应用程序，那么选择Spring Insight显然是最佳的。它一直是免费的，但你需要部署你的应用在TC Server上。
如果你想监听本地和远程的进程，我会选择JProfiler或YourKit。这两个也可以帮助Spring Insight来监测、找到性能瓶颈。
JProfiler和YourKit已经能满足我的上述要求。JProfiler、YourKit和Spring Insight都可以跟踪应用程序的类和方法的流向。JProfiler和YourKit可以显示内存使用情况。虽然Spring Insight不可以显示内存使用情况，但它可以很好的显示吞吐量的趋势。这三款性能分析工具功能很清楚，不混乱，而且容易使用。最后，他们都有自己的IDE插件。希望本文能帮助你做出正确的选择。
如何优化java程序设计和编码,提高java性能
下面给你提供一些在JAVA程序的设计和编码中，经常采用的一些方法和技巧，可以提高JAVA程序的性能：
1．对象的生成和大小的调整。
JAVA程序设计中一个普遍的问题就是没有好好的利用JAVA语言本身提供的函数，从而常常会生成大量的对象（或实例）。由于系统不仅要花时间生成对象，以后可能还需花时间对这些对象进行垃圾回收和处理。因此，生成过多的对象将会给程序的性能带来很大的影响。
例1：关于String ,StringBuffer，+和append
JAVA语言提供了对于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五个对象变量。这些生成的类的实例一般都存放在堆中。堆要对所有类的超类，类的实例进行初始化，同时还要调用类极其每个超类的构架器。而这些操作都是非常消耗系统资源的。因此，对对象的生成进行限制，是完全有必要的。
经修改，上面的代码可以用如下的代码来替换。
StringBuffer name=new StringBuffer("HuangWeiFeng");
System.out.println(name.append("is my name.").toString());
系统将进行如下的操作：
(1) 生成新的字符串缓冲变量new StringBuffer(STR_BUF_1);
(2) 复制该字符串缓冲变量;
(3) 加载字符串常量"HuangWeiFeng"(STR_1);
(4) 调用字符串缓冲的构架器（Constructor）;
(5) 保存该字符串缓冲到数组中（从位置1开始）;
(6) 从java.io.PrintStream类中得到静态的out变量;
(7) 加载STR_BUF_1;
(8) 加载字符串常量"is my name"(STR_2);
(9) 以STR_2为参数，调用字符串缓冲(StringBuffer)实例中的append方法;
(10) 对于STR_BUF_1执行toString命令(STR_3);
(11)调用out变量中的println方法，输出结果。
由此可以看出，经过改进后的代码只生成了四个对象变量：STR_1,STR_2,STR_3和STR_BUF_1.你可能觉得少生成一个对象不会对程序的性能有很大的提高。但下面的代码段2的执行速度将是代码段1的2倍。因为代码段1生成了八个对象，而代码段2只生成了四个对象。
代码段1：
String name= new StringBuffer("HuangWeiFeng");
name+="is my";
name+="name";
代码段2：
StringBuffer name=new StringBuffer("HuangWeiFeng");
name.append("is my");
name.append("name.").toString();
因此，充分的利用JAVA提供的库函数来优化程序，对提高JAVA程序的性能时非常重要的.其注意点主要有如下几方面；
(1) 尽可能的使用静态变量（Static Class Variables）
如果类中的变量不会随他的实例而变化，就可以定义为静态变量，从而使他所有的实例都共享这个变量。
例：
public class foo
{
SomeObject so=new SomeObject();
}
就可以定义为：
public class foo
{
static SomeObject so=new SomeObject();
}
(2) 不要对已生成的对象作过多的改变。
对于一些类(如：String类)来讲，宁愿在重新生成一个新的对象实例，而不应该修改已经生成的对象实例。
例：
String name="Huang";
name="Wei";
name="Feng";
上述代码生成了三个String类型的对象实例。而前两个马上就需要系统进行垃圾回收处理。如果要对字符串进行连接的操作，性能将得更差，因为系统将不得为此生成更多得临时变量，如上例1所示。
(3) 生成对象时，要分配给它合理的空间和大小JAVA中的很多类都有它的默认的空间分配大小。对于StringBuffer类来讲，默认的分配空间大小是16个字符。如果在程序中使用StringBuffer的空间大小不是16个字符，那么就必须进行正确的初始化。
(4) 避免生成不太使用或生命周期短的对象或变量。对于这种情况，因该定义一个对象缓冲池。以为管理一个对象缓冲池的开销要比频繁的生成和回收对象的开销小的多。
(5) 只在对象作用范围内进行初始化。JAVA允许在代码的任何地方定义和初始化对象。这样，就可以只在对象作用的范围内进行初始化。从而节约系统的开销。
例：
SomeObject so=new SomeObject();
If(x==1) then
{
Foo=so.getXX();
}
可以修改为：
if(x==1) then
{
SomeObject so=new SomeObject();
Foo=so.getXX();
}
2．异常(Exceptions)
JAVA语言中提供了try/catch来发方便用户捕捉异常，进行异常的处理。但是如果使用不当，也会给JAVA程序的性能带来影响。因此，要注意以下两点：
(1) 避免对应用程序的逻辑使用try/catch
如果可以用if,while等逻辑语句来处理，那么就尽可能的不用try/catch语句。
(2) 重用异常
在必须要进行异常的处理时，要尽可能的重用已经存在的异常对象。以为在异常的处理中，生成一个异常对象要消耗掉大部分的时间。
3. 线程(Threading)
一个高性能的应用程序中一般都会用到线程。因为线程能充分利用系统的资源。在其他线程因为等待硬盘或网络读写而 时，程序能继续处理和运行。但是对线程运用不当，也会影响程序的性能。
例2：正确使用Vector类
Vector主要用来保存各种类型的对象（包括相同类型和不同类型的对象）。但是在一些情况下使用会给程序带来性能上的影响。这主要是由Vector类的两个特点所决定的。第一，Vector提供了线程的安全保护功能。即使Vector类中的许多方法同步。但是如果你已经确认你的应用程序是单线程，这些方法的同步就完全不必要了。第二，在Vector查找存储的各种对象时，常常要花很多的时间进行类型的匹配。而当这些对象都是同一类型时，这些匹配就完全不必要了。因此，有必要设计一个单线程的，保存特定类型对象的类或集合来替代Vector类.用来替换的程序如下（StringVector.java）：
public class StringVector
{
private String [] data;
private int count;
public StringVector()
{
this(10); // default size is 10
}
public StringVector(int initialSize)
{
data = new String[initialSize];
}
public void add(String str)
{
// ignore null strings
if(str == null) { return; }
ensureCapacity(count + 1);
data[count++] = str;
}
private void ensureCapacity(int minCapacity)
{
int oldCapacity = data.length;
if (minCapacity oldCapacity)
{
String oldData[] = data;
int newCapacity = oldCapacity * 2;
data = new String[newCapacity];
System.arraycopy(oldData, 0, data, 0, count);
}
}
public void remove(String str)
{
if(str == null) { return; // ignore null str }
for(int i = 0; i count; i++)
{
// check for a match
if(data[i].equals(str))
{
System.arraycopy(data,i+1,data,i,count-1); // copy data
// allow previously valid array element be gc′d
data[--count] = null;
return;
}
}
}
public final String getStringAt(int index)
{
if(index 0) { return null; }
else if(index count) { return null; // index is # strings }
else { return data[index]; // index is good }
}
}
因此，代码：
Vector Strings=new Vector();
Strings.add("One");
Strings.add("Two");
String Second=(String)Strings.elementAt(1);
可以用如下的代码替换：
StringVector Strings=new StringVector();
Strings.add("One");
Strings.add("Two");
String Second=Strings.getStringAt(1);
这样就可以通过优化线程来提高JAVA程序的性能。用于测试的程序如下（TestCollection.java）:
import java.util.Vector;
public class TestCollection
{
public static void main(String args [])
{
TestCollection collect = new TestCollection();
if(args.length == 0)
{
System.out.println("Usage: java TestCollection [ vector | stringvector ]");
System.exit(1);
}
if(args[0].equals("vector"))
{
Vector store = new Vector();
long start = System.currentTimeMillis();
for(int i = 0; i 1000000; i++)
{
store.addElement("string");
}
long finish = System.currentTimeMillis();
System.out.println((finish-start));
start = System.currentTimeMillis();
for(int i = 0; i 1000000; i++)
{
String result = (String)store.elementAt(i);
}
finish = System.currentTimeMillis();
System.out.println((finish-start));
}
else if(args[0].equals("stringvector"))
{
StringVector store = new StringVector();
long start = System.currentTimeMillis();
for(int i = 0; i 1000000; i++) { store.add("string"); }
long finish = System.currentTimeMillis();
System.out.println((finish-start));
start = System.currentTimeMillis();
for(int i = 0; i 1000000; i++) {
String result = store.getStringAt(i);
}
finish = System.currentTimeMillis();
System.out.println((finish-start));
}
}
}
关于线程的操作，要注意如下几个方面：
(1) 防止过多的同步
如上所示，不必要的同步常常会造成程序性能的下降。因此，如果程序是单线程，则一定不要使用同步。
(2) 同步方法而不要同步整个代码段
对某个方法或函数进行同步比对整个代码段进行同步的性能要好。
(3) 对每个对象使用多”锁”的机制来增大并发。
一般每个对象都只有一个”锁”，这就表明如果两个线程执行一个对象的两个不同的同步方法时，会发生”死锁”。即使这两个方法并不共享任何资源。为了避免这个问题，可以对一个对象实行”多锁”的机制。如下所示：
class foo
{
private static int var1;
private static Object lock1=new Object();
private static int var2;
private static Object lock2=new Object();
public static void increment1()
{
synchronized(lock1)
{
var1++;
}
}
public static void increment2()
{
synchronized(lock2)
{
var2++;
}
}
}
4．输入和输出(I/O)
输入和输出包括很多方面，但涉及最多的是对硬盘，网络或数据库的读写操作。对于读写操作，又分为有缓存和没有缓存的；对于数据库的操作，又可以有多种类型的JDBC驱动器可以选择。但无论怎样，都会给程序的性能带来影响。因此，需要注意如下几点：
(1) 使用输入输出缓冲
尽可能的多使用缓存。但如果要经常对缓存进行刷新（flush）,则建议不要使用缓存。
(2) 输出流(Output Stream)和Unicode字符串
当时用Output Stream和Unicode字符串时，Write类的开销比较大。因为它要实现Unicode到字节(byte)的转换.因此，如果可能的话,在使用Write类之前就实现转换或用OutputStream类代替Writer类来使用。
(3) 当需序列化时使用transient
当序列化一个类或对象时，对于那些原子类型（atomic）或可以重建的原素要表识为transient类型。这样就不用每一次都进行序列化。如果这些序列化的对象要在网络上传输，这一小小的改变对性能会有很大的提高。
(4) 使用高速缓存（Cache）
对于那些经常要使用而又不大变化的对象或数据，可以把它存储在高速缓存中。这样就可以提高访问的速度。这一点对于从数据库中返回的结果集尤其重要。
(5) 使用速度快的JDBC驱动器（Driver）
JAVA对访问数据库提供了四种方法。这其中有两种是JDBC驱动器。一种是用JAVA外包的本地驱动器；另一种是完全的JAVA驱动器。具体要使用哪一种得根据JAVA布署的环境和应用程序本身来定。
5.一些其他的经验和技巧
(1) 使用局部变量。
(2) 避免在同一个类中动过调用函数或方法(get或set)来设置或调用变量。
(3) 避免在循环中生成同一个变量或调用同一个函数（参数变量也一样）。
(4) 尽可能的使用static,final,private等关键字。
(5) 当复制大量数据时，使用System.arraycopy()命令。
Java反射的性能为什么比直接调用慢一个数量级左右
反射肯定比直接调用慢
这个毋庸置疑了，我这篇文章也不是证明反射有多高效的。
现在的快递哥很火，那我们就举个快递的例子。如果快递员就在你住的小区，那么你报一个地址：xx栋xx号，那么快递员就可以马上知道你在哪里，直接就去到你家门口；但是，如果快递员是第一次来你们这里，他是不是首先得查查百度地图，看看怎么开车过去，然后到了小区是不是得先问问物管xx栋怎么找，然后，有可能转在楼下转了两个圈才到了你的门前。
我们看上面这个场景，如果快递员不熟悉你的小区，是不是会慢点，他的时间主要花费在了查找百度地图，询问物业管理。OK，反射也是一样，因为我事先什么都不知道，所以我得花时间查询一些其他资料，然后我才能找到你。大家有兴趣可以查看反射的实现原理，以及MetaData的相关概念。
反射到底比直接调用慢多少?
好了，我们知道反射肯定慢的，那么是不是反射就不能用了呢？有些人一听到慢，就非常着急的下结论，反射怎样怎样不行，怎样怎样不能用。但是，同学，反射到底比直接调用慢多少，你造吗，能给我个实际的数据吗？很多人其实对性能只有个模糊的概念，而没有数值支撑。之前我给同事找了一个动态解析表达式的类库，他觉得不太好用，他很聪明，很快的找到了用DataTale.Compute可以实现公式的动态解析。我问他，这个方法和我给的类库性能上有什么区别？他跟我说，这个已经很快了，执行1秒都不到。我一听，就觉得不对劲，你的思想还停留在秒级，跟我谈什么性能?
怎么去判断一个函数的性能?因为函数的执行太快太快了，你需要一个放慢镜，这样才能捕捉到他的速度。怎么做？把一个函数执行一百万遍或者一千万遍，你才能真正了解一个函数的性能。也就是，你如果想判断性能，你就不能还停留在秒级，毫秒级的概念，你必须用另外一个概念替代，才能知道真正的性能。结果我同事把这两种方法执行了100w遍，确实，我提供的类库比他的快了8秒。
好了，现在拿我早两天提供的工厂方法来做测试，其中CodeTimer的实现参考赵大神的文章《一个简单的性能计数器：CodeTimer》：
测试方法如下：
代码如下
复制代码
[Test]
public void TestReflector()
{
CodeTimer.Time("Direct", 100 * 10000,
() =
{
var instance = new ConnectionTest();
});
CodeTimer.Time("Reflect", 100 * 10000,
() =
{
this.GetType().Assembly.CreateInstance("TestPropertyGrid.ConnectionTest");
});
}
测试结果如下：
Direct
Time Elapsed: 25ms
CPU Cycles: 57,582,163
Gen 0: 14
Gen 1: 0
Reflect
Time Elapsed: 3,231ms
CPU Cycles: 8,001,720,795
Gen 0: 269
Gen 1: 1
看到没，我们的放大镜起作用了，现在我们大概可以下这么一个结论：在执行100万遍的时候，反射大概把直接调用慢50~100倍。100倍，咋一看，是相差很大的，但是，我前文说了，别着急下结论，你要看看前提条件。自古我们就喜欢断章取义，比如“以德报怨”这个成语，好像古人说让我们遇到不好的，你不能怨恨，要更好的对待他人，别人打你左脸一巴掌，你应该把右脸伸过去让他再打一下。但实际这个成语是怎样的呢？
或曰：“以德报怨，何如？”
子曰：“何以报德？以直报怨，以德报德”
老孔的意思其实是如果别人对你好，那么你就对他好，要是他招你惹你了，你就干他娘的！你看，傻眼了吧？
有多少情况下需要考虑反射带来的影响?
我认为这个情况是非常非常少的，绝大多数的我们根本就无需考虑这个。就上我上一篇文章提到的工厂，你程序有多少个实体，有100万个吗？如果你只是在弹出窗口的时候new一下，这个百万分之十秒的影响对你很重要吗？
另外，有些人讲，我要是真有这种需求，要把一个对象new一百万遍，那不还是慢吗？这种情况有没有，有！比如我有100w条记录，需要取出来，然后通过反射赋值到一个Model类中。
但是对于这种情况，如果你真是这么想的话，我只能说，你坐办公室坐久了，脑袋生锈了，该去爬爬山，泡泡妞了。如果你需要对一个对象反射一百万遍，那么你就应该缓存这个对象了。拿我们上面那个例子来说，如果这个快递员给小区的人送一百万遍的快递还认不得路，每次都还得百度地图，然后问物业管理，你丫的你还没把他开掉了，那你脑袋不是秀逗了，要不就是任性的有钱人。
上面代码如果缓存之后执行一百万遍，跟直接调用有多大的区别？我这里就不贴代码了，免得你们直接看结果没有意思，自己把代码敲一遍，印象更深刻。
那么，还有没有更快的办法，有。比如你的快递员开始用的是IPHONE4，现在可以考虑给他买个6+。在.net中，提供了Emit的相关方法来让你更快的反射。这里送你一个通过反射快速给Model赋值的轮子“Dapper”，自己回家造去。
编程中是否应该使用反射？
其实看完上面的文字，我相信你们都有了一个初步的判断，而我的看法是：绝大多数的情况下你都可以用反射。
如果你觉得是因为反射导致你程序慢的话，那么，请先用放慢镜好好观察一下，到底是不是反射的问题。如果你确定是反射的问题，那么你再好好的考虑下是不是你没有用对反射，是不是像上面那个走了一百万遍都不认识路的快递员一样。最后，如果你觉得性能上还是不够，那么我建议你升级下硬件吧，把硬件性能上升个3%总好过你请个牛逼的工程师来帮你做这种极限的优化，有一句话我觉得很对“工程师比服务器要昂贵的多”。如果你还非得跟我较劲，那么，没办法了，你程序对性能的要求已经超出了本文讨论的范畴，如果你真有这种需求了，我觉得你也没有必要看我这篇文章了，因为你已经足够牛逼到对系统语言都有深入了解了。
大多时候，我们会把程序的性能归结于编程语言，或者使用了反射等技术，而甚少去关心自己的代码，这种心态会导致你技术的发展越来越缓慢，因为你已经失去了求知的欲望，以及一颗追求技术进步的心。请你记住，更多的时候，影响我们程序性能的，是你编程的思想，你对待编码的态度！
总结
好吧，说了这么多，估计很多人直接就拖到文章末尾然后因为文章码了这么多字而默默点了个赞，那么，我在最后给大家奉献一下本文的精华：
反射大概比直接调用慢50~100倍，但是需要你在执行100万遍的时候才会有所感觉
判断一个函数的性能，你需要把这个函数执行100万遍甚至1000万遍
如果你只是偶尔调用一下反射，请忘记反射带来的性能影响
如果你需要大量调用反射，请考虑缓存。
你的编程的思想才是限制你程序性能的最主要的因素
怎么做JAVA程序性能优化
1）尽量指定类、方法的final修饰符。带有final修饰符的类是不可派生的，Java编译器会寻找机会内联所有的final方法，内联对于提升Java运行效率作用重大，此举能够使性能平均提高50%。
2）尽量重用对象。由于Java虚拟机不仅要花时间生成对象，以后可能还需要花时间对这些对象进行垃圾回收和处理，因此生成过多的对象将会给程序的性能带来很大的影响。
3）尽可能使用局部变量。调用方法时传递的参数以及在调用中创建的临时变量都保存在栈中速度较快，其他变量，如静态变量、实例变量等，都在堆中创建速度较慢。
4）慎用异常。异常对性能不利，只要有异常被抛出，Java虚拟机就必须调整调用堆栈，因为在处理过程中创建了一个新的对象。异常只能用于错误处理，不应该用来控制程序流程。
5）乘法和除法使用移位操作。用移位操作可以极大地提高性能，因为在计算机底层，对位的操作是最方便、最快的，但是移位操作虽然快，可能会使代码不太好理解，因此最好加上相应的注释。
6）尽量使用HashMap、ArrayList、StringBuilder，除非线程安全需要，否则不推荐使用 Hashtable、Vector、StringBuffer，后三者由于使用同步机制而导致了性能开销。
尽量在合适的场合使用单例。使用单例可以减轻加载的负担、缩短加载的时间、提高加载的效率，但并不是所有地方都适用于单例。
java性能计数的介绍就聊到这里吧，感谢你花时间阅读本站内容，更多关于java性能提升、java性能计数的信息别忘了在本站进行查找喔。