性能优化之设计层优化篇(常用优化组件和方法)

    可用于系统性能优化的组件有缓冲、缓存两个组件；

    常用的几种优化思想：池化对象、并行代替串行、负载均衡；

    1、缓冲(Buffer)

           缓冲区是一块特定的内存区域。开辟缓冲区的目的是通过缓解应用程序上下层之间的性能差异，从而起到提高系统性能。（日常生活动的漏斗就是这个道理）

           注意：缓冲可以协调下层组件和下层组件的性能差。当上层组件性能优于下层组件时，可以有效的减少上层组件对下层组件的等待时间。

           缓冲最常用的场景就是提高I/O的速度。JDK中也有不少I/O组件都提供了缓冲功能。例如：BufferedWriter、BufferedOutputStream

           以BufferedWriter为例：

      public class  WriterTest {          public void test(){              try {                   Writer writer = new FileWriter(new File("D:\\opt\\1.jpg"));                   long begin = System.currentTimeMillis();                   for(int i=0;i<1000000;i++){                      writer.write(i);                   }                   writer.close();                   System.out.println("spend:"+(System.currentTimeMillis()-begin));               } catch (IOException e) {                   // TODO Auto-generated catch block                   e.printStackTrace();               }          }                    public void test1(){              try {                  Writer writer = new BufferedWriter(new FileWriter(new File("D:\\opt\\1.jpg")));                  long begin = System.currentTimeMillis();                  for(int i=0;i<1000000;i++){                      writer.write(i);                  }                  writer.close();                  System.out.println("buffer_spend:"+(System.currentTimeMillis()-begin));              } catch (IOException e) {                  // TODO Auto-generated catch block                  e.printStackTrace();              }          }                    public static void main(String[] args) {              WriterTest test = new WriterTest();             test.test();               test.test1();           }      }

    2、缓存（Cache）
          缓存（Cache）是为提升系统性能而开辟的一块内存空间。

          主要作用：暂存数据处理结果，并提供下次访问使用。通过将来之不易的数据处理结果暂存起来，当有其他线程、客户端需要查询相同的数据资源时直接使用，这样就可以省略对这些数据的处理流程，而直接从缓存中获取处理结果。

          HashMap就可以实现简单的缓存。（注：线程不安全的）

     public class CacheTest {         //参数介绍：2000为缓存最大值；0.75f为负载因子；true为按照访问顺序，false为按照插入顺序         static LinkedHashMap<String, Object> cache = new LinkedHashMap<String, Object>(2000,0.75f,true){             private static final long serialVersionUID = 1L;                     @Override             protected boolean removeEldestEntry(Map.Entry<String, Object> eldest) { //超过2000最大值时，删除最老、最不常用的数据                 return size() > 2000;             }                 };             public static void main(String[] args) {             CacheTest.cache.put("a", "b");             System.out.println(cache.get("a")+"==="+cache.size());         }         }

    3、对象复用--池

    4、并行替代串行

    5、负载均衡

          以网站应用为例，如果并发数非常多，单台服务器无法承受时，为保证应用程序的服务质量，就需要使用多台服务器协同工作，将系统负载尽可能均匀地分配到各个服务器节点上；当某一个服务节点宕（dang）机时，其他节点也可以保证服务正常运行。

          注意：在使用负载均衡时，使用Session信息将会存在信息不同步问题，当然通过复制Session信息在所有的节点上保持一致可以解决不同步问题，但是会出现新的问题，就是很容易造成网络繁忙，影响系统效率。所以综上所述我们可以根据实际情况而定，使用cookie方式保存信息。

    6、时间换空间

          时间换空间通常用于嵌入式设备或者内存、硬盘空间不足的情况。通过使用牺牲CPU的方式，获得原本需要更多内存或者硬盘空间才能完成的工作。

          举个非常简单的时间换空间的算法，实现a、b两个变量的值交换。交换两个变量最常用的方法是使用一个中间变量，而引入额外的变量就意味着要使用更多的空间。采用下面的方法则可以免除中间变量，而达到变量变换的目的，代价是引入更多的CPU运算。

     public class SJHKJ {         public static void main(String[] args) {             int a = 1;             int b = 2;             System.out.println("a="+a+"-----b="+b);             a = a+b;             b = a-b;             a = a-b;             System.out.println("a="+a+"-----b="+b);         }         }

   7、空间换时间

          与时间换空间的方法相反，空间换时间则是尝试使用更多的内存或者磁盘空间换取CPU资源或者网络资源等，通过增加系统的内存消耗，来加快程序的运行速度。典型的应用实例就是缓存。

public class KJHSJ {        public static int arrayLen = 1000000;        public static void main(String[] args){        int[] a = new int[arrayLen];        int[] old = new int[arrayLen];        Map<Integer, Object> map = new HashMap<Integer, Object>();        int count = 0;        while(count<a.length){ //初始化数组数据            int value = (int)(Math.random()*arrayLen*10)+1;            if(map.get(value)==null){                map.put(value, value);                a[count] = value;                count++;            }        }        System.arraycopy(a, 0, old, 0, a.length);//这里只是为了保存原有数组        long start = System.currentTimeMillis();        Arrays.sort(a);        System.out.println("Arrays.sort spend:"+(System.currentTimeMillis()-start)+" ms");        System.arraycopy(old, 0, a, 0, old.length);//恢复原有数据        start = System.currentTimeMillis();        spaceToTime(a);        System.out.println("spaceToTime spend:"+(System.currentTimeMillis()-start)+" ms");    }        public static void spaceToTime(int[] array){        int i=0;        int max = array[0];        int l = array.length;        for(i = 1;i<l;i++){            if(array[i]>max){//找到最大值                max = array[i];            }        }        int[] temp = new int[max+1]; //分配临时空间        for(i=0;i<l;i++){            temp[array[i]] = array[i];  //以索引下标来表示数字大小        }        int j =0;        int max1=max+1;        for(i=0;i<max1;i++){  //线性复杂度            if(temp[i]>0){                array[j++] = temp[i];            }        }    }}

          使用spaceToTime()实现数据的排序耗时要比使用JDK自带的数组排序方法Arrays.sort()的排序要节省一倍的时间。（数据100万，运行在我的机器上）

          之所以速度要优于JDK自带的方法，是因为它不计空间成本，以数组的索引下标来表示数据的大小，这样就避免了数字间的相互比较。

          注意：如果数组中的元素不多时或者当前服务器的CPU运算能力很强，那么JDK自带的排序方法Arrays.sort()的执行速度不一定比spaceToTime()慢，视情况而定。