java深度-----effective java，

java深度-----effective java，

[code]
高性能java

1.开发高性能java程序的原则与方法
优化程序代码的注意事项：
1。除非必须优化，否则不要轻易改动
2。改动之后要进行仔细的测试
3。在各个JVM产品中是不存在一劳永逸的成本模型
(在某个虚拟机上做的优化效果非常好，但是到了别的虚拟机上就不一定重现了)

2。先把焦点放在设计，数据结构和算法上

每一个方法不应该长，可以方法里面引入方法，这样jit所做的工作就会少

1。使用StringBuffer来做拼接
因为如果用String，那么很多对象将在Eden区域产生，很可能在此时造成垃圾全收集的产生
StringBuffer b = new StringBuffer("a"); //这里只产生一个对象，因为他会把a这个二进
制的东西（注意这时还不是一个对象），加到b这个对象里面，所以只有一个对象。
注意："a"有两种身份，第一种身份是对象，第二种身份是和int这中东西一样的基础类型
所以使用StringBuffer来操作字符串拼接，那么从始至终都只有一个对象哈，虽然在传值给
append的时候传递了"a"这种东西，但是这个时候他不是一个对象


2。javap -c Test 可以生成字节码文件
通过字节码我们知道加入同步控制会导致字节码指令体积会增加
同步方法获取的是对象锁

Class Test{
public synchronized void m1(){
}
public synchronized void m2(){
}
public synchronized void m3(){
}
public synchronized void m4(){
}
}
//注意啦，这四个方法居然用了同一把锁，就是这个对象锁(this),
那么第一：四个方法只能由一个方法在一个时间内使用
第二：如果方法里面有全局变量，对象所还没有用，因为别的线程很可能
new一个自己的对象，还是可以进入这个方法来
所以千万不要使用方法同步
我们一般用字节数组作为锁变量

class Test{
private byte[] lock1 = new byte[0]; //技巧哈
private byte[] lock2 = new byte[0];

public void m1(){
synchronized(lock1){
//======================
}
}
}

尽量使用stack变量和基本类型完成必要的任务
一个方法的局部变量会存放在这个方法的运行时栈当中
stackAccess方法性能要高于staticAccess以及instacevarAccess
staticAccess和instacevarAccess方法的性能大体一致，因为他们都是从常量池中去得到实例变量
所以尽可能的使用局部变量
class StackVar{
private int instvar;
private static int staticvar;

void stackAccess(int val){
int j=0;
for(int i=0;i<val;i++){
j +=1; //这是对局部变量++
}
}

void instacevarAccess(int val){
//每次都要访问常量池，性能有问题，第二并发有问题
for(int i=0;i<val;i++){
instvar += 1; //这是对实例变量++
}
}

void instacevarAccessPer(int val){
int j= instvar;
for(int i=0;i<val;i++){
j+=1;
}
instvar = j;
}

void staticAccess(int val){
for(int i=0;i<val;i++){
staticvar += 1; //对静态变量++
}
}

void staticAccessPer(int val){
//性能不错，只需要访问两次常量池，
//其他操作都是在本地栈中完成的
int j=staticvar;
for(int i=0;i<val;i++){
j+=1; //对局部变量++然后赋值给静态变量
}
staticvar = j;
}
}

使用static final private 函数以促成inlining
内联函数会使用函数的代码来替换函数的调用，将函数的代码原封不动的
拷贝到调用处，省去了函数调用的消耗，以促使性能的提升，但是如果你将一个
函数声明为static final private那么java编译器就会把这种函数作为inlining
的候选者，为什么是候选者呢？因为如果你的函数写的非常大的话，那么他会使得你函数的体积
发生激增，所以Java编译器会先看下代码的长度，代码太长他也不会把他变为内陆函数的

实例变量初始化一次就好
如果你new一个类，那么java虚拟机如何对他初始化
1。在堆中分配内存
2。对实例变量进行缺省值的初始化
3。执行构造方法的赋值动作

但是如果我们private int count=1；这么搞则有四步
1。在堆中分配内存
2。对实例变量进行缺省值的初始化
3。覆盖缺省值
4。执行构造方法的赋值动作

或者有初始化区段，比如static{}
那么
1。在堆中分配内存
2。对实例变量进行缺省值的初始化
3。初始化区段---这个虽然是static的，但确是在实例变量缺省值初始化之后
4。执行构造方法的赋值动作
class Foo{
private int count; //private int count=1；这样也会被执行两次，先执行缺省值赋值，
private boolean done;
private Point pt;
private Vector ver;
public Foo(){
count = 0; //这个东西被初始化了两次哈
done = false; //他的缺省值本来就是false,他又初始化一次
pt = new Point(0,0);
vec = new Vector(10);
}
}

class Foo{
private int count;
private boolean done;
private Point pt;
private Vector ver;
public Foo(){
pt = new Point(0,0);
vec = new Vector(10);
}
}

集群类对象的处理
1.数组，HashTable,Vector,Stack等数据结构类用于容纳和处理对象
注意：Collection类里面放的都是对象哈。。简单类型也会自动转型才被放入
1。权衡使用迭代器：Iterator,ListIterator,Enumeration
class AccessCollection{
public int enumCec(Vector vec){ //比较快，比后面的快10%
Enumeration enum = ver.elements();
int toral = 0;
while(enum.hasMoreElements()){ //在这里访问了一次容器，就比forVec慢了
total = ((Integer))(enum.nextElement()).iniValue();
}
return total;
}

public int iterVec(Vector vec){
Iterator it = vec.iterator();
int total = 0;
while(it.hasNext()){
total +=((Integer))(it.next()).iniValue();
}
return total;
}

public int listiterVec(Vector vec){
ListIterator it = vec.listIterator();
int total = 0;
while(it.hasNext()){
total +=((Integer))(it.next()).iniValue();
}
return total;
}

public int forVec(Vector vec){//最快，比前三个方法快35%
int size = vec.size();
int total = 0;
for(int i=0;i<size;i++){
total +=((Integer)vec.get()).intValue();
}

}
}

如何复制数组元素：
使用循环复制；---不好
使用System.arraycopy()方法---好，比循环复制快两倍，
因为他采用操作系统底层的复制，而不是采用循环的方式
System.arraycopy(src,0,des,0,src.length);
从原数组第0个元素开始拷贝，拷贝的长度为src.length;
把他拷贝到des时，以第0个位置作为起始元素

优先数组，然后考虑群积类，尤其是在性能优先的需求中；
如果需要群集类功能，但又不考虑同步，可以先选择非同步的集群类如ArrayList;
如果需要集群类功能，又要顾及到数据同步保护时，可以选择同步集群类，如Vector;
如果选择集群类，要分清集群类使用的目的

注意：不要因为有个个数无法确定的数据需要存储，就毫无选择的使用集群类，出现这种情况可以考虑创建一个足以
容纳大量数据的array,这可能造成内存浪费，但是在性能上往往会获得更大的收益


[/code]