java性能优化

• 二八原则:百分之二十的系统设计消耗了80%的系统性能,如果可以找到这20 的缺陷代码,那么我们就可以比较容易的优化和解决80的性能问题.

• 所有的语言都要使用编译器

• 如果A文件依赖B文件,编译器应该做到以下两点:
  只有在B文件编译完成之后,A才开始编译
  B文件发生变化的时候,A文件会重新编译

• DNS路由负载(前端负载)

• 减少网页上附带的图片可以大大降低网络带宽压力

• 前端页面静态化,让用户直接从内存中读取这些信息

• 优化查询,反向代理

• 缓存问题:
  缓存更新,缓存换页,缓存持久化

• 相同条件下,32位的JVM比64位的性能好,然而32位的JVM最大支持的堆内存是4GB(无论在32还是64位的,实际可分配的内存只有2-3GB),如果需要更大的堆内存,还是使用64位的JVM比较合适.

• 云计算 网络 异构计算 多核 虚拟化

• 云计算甚至可以让你体验每秒10亿次的运算,可以模拟核爆炸,预测天气和市场发展趋势(按使用量付费的模式)

• java对内存的分配一般有三种方式:
  静态存储区域分配 static
  在栈上创建 函数内部局部变量的存储单元度可以在栈上创建,函数执行结束时候这些单元呗自动释放,栈内存分配运算内置于处理器的指令集中,效率很高,但是分配的内存有限.
  在堆内分配,亦称动态内存分配,程序在运行的时候用malloc或者new申请任意多少的内存,程序猿自己负责在何时free或者delete释放内存,动态内存的生存期由我们决定,使用非常灵活,但是问题也很多.

• java虚拟机将内存数据氛围程序计数器,虚拟机栈,本地方法栈,java堆和方法区域线程共享和线程私有,虚拟机栈和本地方法栈用于存放函数调用的堆栈信息,java堆用于存java程序运行时候所需要的对象等数据,方法区用于存放类元数据信息.

• 程序计数器是私有的,各个线程互不影响,独立存储,因此这块内存是线程私有的

• JVM的架构是基于栈的,即程序指令的每一个操作都是要经过入栈和出栈的操作

• java编译预先生成对应的内存空间,当我们尝试创建程序的时候,java编译器必须知道被存储在栈内的确切大小和生命周期,一遍可以按照上面的成熟分配春初和动态调整内存空间,因此只有某些数据 如对象的引用存在栈内,庞大的java对象存在堆内.

• 栈的存取速度很快,仅次于寄存器,并且帐数据是可以被共享的,栈的缺点是栈内的数据带下和生存期必须是确定的(缺乏灵活性),虚拟机栈主要存放一些基本类型的变量,如 int short,long,byte,byte,float,double,boolean,char,以及这些对象引用.

• Object类clone方法返回的是一个对象,而不是一个对象的引用地址,二是拷贝对象与new关键字返回的新对象的区别是,这个拷贝对象已经包含了原来对象的信息,而不是初始信息,即每次拷贝动作不是一个针对全薪对象的创建.

• 使用clone创建对象,原有的信息会被保留,因此创建速度会加快.

• 建议多使用局部变量,布局变量被保存在Stack中 腹泻速度比较快,其他变量,如静态变量,实例变量,他们都在堆中被创建,也被保留在那里.

• 局部变量执行速度远高于类的成员变量

• 运算效率最高的方式:位运算

• 逻辑运算符(包括~,&,|,^)以及移位运算符>> << >>> (比如a*=2 a/=2 a<<=1 a>>=1) >>>和>>的区别是,在执行运算的时候,>>>运算符的操作位数高位补0,而>>运算符高位移入原来的

• 判断某个元素是否在数组中的时候,可以采用ArrayList.asList(array).contains(T obj);

• ArrayList变数组,ArrayList.toArray(T[] array)

• linkedList由一系列链表组成,一个表项由元素内容,前驱表项和后驱表项.

• LinkedList不要用get方法,即使LinkedList的元素只有很少的几个,发生这个情况是因为LinkedList底层是一个链表,随机访问i的时候,链表只能从前往后数,第i个才返回,所以随着i的变大时间会越来越长
  -`

    public class LinkedListWrongDemo{
    		public static void main(){
    				int size=20000;
    				List<String> list=new LinkedList();
    					for(int i=0;i<size;i++){
    							list.add("this is only test data");
    }
    long start=system.currentTimeMills();
    for(int i	=0;i<list.size();i++){
    				if(i%10000==0){
    			system.out.print("10000次耗费的时间为");	
    			starttime=system.currentTimeMills();			
    }
    
    			}
    }
    }`
  

• 只有数组才能支持快速访问,而链表的随机访问需要进行链表的遍历
  -可以判断是否实现了RandomAccess 如ArrayList还是SequenceList,因为适合RandomAccessList的遍历算法,用在Sequence LIst上差别就很大,常用的办法就是做一个判断

if(list instanceof RandomAccess){
	for(int m=0;m<list.size();m++){
	}
}else{
	Iterator iter=list.iterator();
	while(iter.hasNext()){}
}

• hashmap实际是一个链表的数组,基于hashmap的链表方式实现机制,只要hashCode()和hash()方法实现足够好,能够尽可能减少冲突的产生,那么对hashmap的操作几乎等价对数组的随机访问操作,具有很好的性能,存储时候,根据key的值hashcode值之后,系统会根据该hashcode值来决定该元素的存储位置.

• 增加负载因子可以减少Hash表(就是那个Entry数组)所占用的内存空间,但会增加查询数据的的时间开销.

• hashmap的高性能需要三点保证:
  1是提供高效的hash算法
  2保证hash值到内存地址的映射速度
  3.根据内存地址可以直接渠道对应的值

• hashset判断同一个对象要重写hashcode和equals方法

• lambda表达式由三部分组成:参数列表,箭头,以及一个表达式或者是一个语句块

• java8循环list List name=new LinkedList<>();
  name.forEach(name-> System.out.print(name))

• JAVA 统计长单词

String  content=new String(Files.readAllBytes(Path.get("d:\\xxx.pom.xml")))
List<String> words=Arrays.asList(content.spilt("\n"));
int count=0;
for(String w:words){
	if(w.length()>12)count++;
}

java 8
int count =words.stram().filter(w->w.length()>12).count();
system.out.println(count);

• java8集合不仅有stram()方法,该方法返回一个连续的数据流,java8集合类还有还有一个parallelStream(),该方法返回一个并行流.作用为在允许管道操作的同时在不同的java线程中执行以提高性能.
• 使用包含变量的表达式来创建string对象,则不仅会检查并维护string池,而且还会在堆栈区创建一个string对象
• 切割字符串

String tmp=aee;
while(true){
	String spiltStr=null;
	int j=tmp.indexof(",");
	if(j<0){
		break;
	}
	spiltStr=temp.substring(0,j);
	temp=temp.substring(j+1);
}

• 绝对不会出现乱码

new String(s.getByte("UTF-8"),"UTF-8")

• 软引用与弱引用的区别就在于,在GC回收的 时候,算法检测是否回收软引用对象,而对于弱引用对象,GC总是进行回收,

LFU算法简单实现
public class SmallHeapDemo{
	final static int MAX_LEN=100;
	private int queue[]=new int[MAX_LEN];
	private int size;
		public void add(int e){
		if(size>MAX_LEN){
			system.err.println("over flow");
			return;
	}
	in s=size++;
	shiftup(s,e);
public int size(){
	return size;
}
private void shiftup(int s,int e){
	while(s>0){
	int parent=(s-1)/2;
	if(queue[parent]<e){
		break;
		}
		queue[s]=queue[parent];
	}
	queue[s]=e;
}
	}
}