引用对象的使用和易产生bug的示例

QuoteTest（引用对象技巧）  

  1 import java.util.ArrayList;
  2 import java.util.HashMap;
  3 import java.util.List;
  4 import java.util.Map;
  5 
  6 /**
  7  * Created by robin on 2016/4/13.
  8  * 引用型对向操作总结：
  9  * 1.被引用的对象，值改变时，会直接改变引用源的值;
 10  * 2.当引用的对象，改变其引用源时，对其操作，只会改变新的引用源的值，并不会影响之前的引用源的值
 11  * 3.从map中获取的引用不存在时，需要将新的引用put到map中，map中该位置的值，才会被引入
 12  * @author robin
 13  */
 14 public class QuoteTest {
 15 
 16     public static void main(String args[]){
 17         Map<String,List<String>> map = new HashMap<String, List<String>>();
 18         for (int i =0;i< 5;i++){
 19             List<String> datalist = new ArrayList<String>();
 20             for (int j=0;j<10;j++){
 21                 datalist.add(i*10+""+j);
 22             }
 23             map.put(""+i,datalist);
 24         }
 25         for (List<String> list:map.values()){
 26             System.out.println(listToString(list));
 27         }
 28         System.out.println("----------分隔线1-----------");
 29         List<String> tempList =  map.get("3");
 30         tempList.add("avc");
 31         tempList.remove("300");
 32         for (List<String> list:map.values()){
 33             System.out.println(listToString(list));
 34         }
 35         System.out.println("----------分隔线2-----------");
 36         List<String> tempList2 =  map.get("2");//tempList 获得map中 key为2的引用
 37         List<String> replaceList = new ArrayList<String>();
 38         tempList2 = replaceList;////tempList 获得其他list的引用，失去map中 key为2的引用，此时对templist2做任何操作，影响的时replaceList引用的区域
 39         tempList2.add("replaceList的值被改变");
 40         for (List<String> list:map.values()){
 41             System.out.println(listToString(list));
 42         }
 43         System.out.println("replaceList的值："+listToString(replaceList));
 44         System.out.println("----------分隔线3-----------");
 45         List<String> tempList3 =  map.get("2");
 46         tempList3 = replaceList;
 47         map.put("2",tempList3);
 48         for (List<String> list:map.values()){
 49             System.out.println(listToString(list));
 50         }
 51         System.out.println("----------分隔线4-----------");
 52         List<String> notExistList = map.get("5");
 53         if(notExistList == null){
 54             notExistList = new ArrayList<String>();
 55         }
 56         notExistList.add("第5行数据添加进来...");
 57         for (List<String> list:map.values()){
 58             System.out.println(listToString(list));
 59         }
 60         System.out.println("----------分隔线5-----------");
 61         List<String> notExistList2 = map.get("6");
 62         if(notExistList2 == null){
 63             notExistList2 = new ArrayList<String>();
 64         }
 65         notExistList2.add("第6行数据添加进来...");
 66         map.put("6",notExistList2);
 67         for (List<String> list:map.values()){
 68             System.out.println(listToString(list));
 69         }
 70         System.out.println("----------分隔线5-----------");
 71 
 72         Map<String,Map<String,String>> mapOne = new HashMap<String, Map<String, String>>();
 73         String keyss = "mapTest";
 74         Map<String,String> mapTwo = new HashMap<String, String>();
 75         mapOne.put(keyss,mapTwo);
 76         System.out.println("mapOne的数据:" + mapToString(mapOne));
 77         System.out.println("----------分隔线6-----------");
 78         mapTwo.put("aaa", "aaav");
 79         mapTwo.put("bbb", "bbbv");
 80         mapTwo.put("ccc","cccv");
 81         System.out.println("mapOne的数据:"+mapToString(mapOne));
 82         System.out.println("----------分隔线7-----------");
 83     }
 84 
 85     private static String listToString(List<String> list){
 86         StringBuilder sb = new StringBuilder("");
 87         for (String s:list){
 88             sb.append("["+s+"] ");
 89         }
 90         return sb.toString();
 91     }
 92 
 93     private static String mapToString(Map<?,?> map){
 94         StringBuilder sb = new StringBuilder("");
 95         for(Map.Entry entry:map.entrySet()){
 96             sb.append("[key:"+entry.getKey()+";value:"+entry.getValue()+"]");
 97         }
 98         return sb.toString();
 99     }
100 
101 }

---------------------

引用对象易产生的bug:

2016.05.11

关于引用对象，使用不恰当，很容易给自己挖坑，产生非常严重的bug，进而导致整个系统实际业务的崩溃，而且这种bug很难被查出来。(如果日志记录不够详细，分析不够彻底，要找出这种bug，只能靠上帝保佑)

下面先上bug 代码 demo

 1 import java.util.Iterator;
 2 import java.util.List;
 3 import java.util.Vector;
 4 
 5 /**
 6  * Created by robin on 2016/5/11.
 7  *
 8  * @author robin
 9  */
10 public class QuoteBugDemo {
11 
12     private static List<Integer> publicNums = new Vector<Integer>();
13 
14     public static void main(String args[]) throws InterruptedException {
15         initPublicNums();//初始化公共数据源
16 
17         timeTask(1);//模拟执行定时任务1
18 
19         timeTask(2);//模拟执行定时任务2
20 
21     }
22 
23 
24     private static void initPublicNums(){
25         for (int i =0;i < 10;i++){
26             publicNums.add(i);
27         }
28     }
29 
30     /**
31      * 这块代码模拟的逻辑：
32      * 1.每天获取配置好10个的数据源；
33      * 2.检查这10个数据源，当数据源的数据准备好后，开始执行数据同步；
34      * 3.从当天的带同步数据源list删除已经同步的数据；
35      * @param mark
36      * @throws InterruptedException
37      */
38     private static void timeTask(int mark) throws InterruptedException {
39         final long start = System.currentTimeMillis();//程序开始运行时间
40         //每天待同步数据源
41         List<Integer> dataSources = publicNums;
42         StringBuffer sb = new StringBuffer("mark("+mark+");公共数据源数目:"+dataSources.size()+"；数据源列表[");
43         for (Integer i:dataSources){
44             sb.append(i+",");
45         }
46         sb.append("]");
47         System.out.println("日志【"+sb.toString()+"】");
48         while(true){
49             long seconds = (System.currentTimeMillis() - start) / 1000;
50             if(seconds > 15l){
51                 System.out.println("运行超过限定时间：15秒，退出");
52                 break;
53             }
54             Iterator<Integer> ite = dataSources.iterator();
55             while (ite.hasNext()){//
56                 int dataSource = ite.next();
57                 boolean flag = isOk(dataSource);
58                 if(flag){//数据源数据已准备好
59                     System.out.println("对数据源:"+dataSource+"进行数据处理。");//同步数据
60                     ite.remove();//待同步数据源删除该数据源
61                 }
62             }
63             if(dataSources.size() != 0){
64                 Thread.sleep(1000);
65             }else{
66                 break;
67             }
68         }
69         System.out.println("定时任务mark["+mark+"]已经执行完毕");
70     }
71 
72     /**
73      * 模拟检查数据源是否OK
74      * @param dataSource
75      * @return
76      */
77     private static boolean isOk(int dataSource){
78         if(dataSource%2 == 0){
79             return true;
80         }
81         return false;
82     }
83 
84 
85 }

执行结果：

 1 日志【mark(1);公共数据源数目:10；数据源列表[0,1,2,3,4,5,6,7,8,9,]】
 2 对数据源:0进行数据处理。
 3 对数据源:2进行数据处理。
 4 对数据源:4进行数据处理。
 5 对数据源:6进行数据处理。
 6 对数据源:8进行数据处理。
 7 运行超过限定时间：15秒，退出
 8 定时任务mark[1]已经执行完毕
 9 日志【mark(2);公共数据源数目:5；数据源列表[1,3,5,7,9,]】
10 运行超过限定时间：15秒，退出
11 定时任务mark[2]已经执行完毕

定时任务2，执行的时候，数据源只剩1,3,5,7,9。

改进方案：将公共数据源保护起来，仅提供公共数据源的副本：shallow copy和deep copy

核心代码：

1 /**
2      * 改进方案1：获取公共数据源对象的副本
3      * shallow copy:list中 元素引用 仍然是相同的
4      * @return
5      */
6     private static List<Integer> getPublicNums(){
7         List<Integer> clone = new ArrayList<Integer>(publicNums);
8         return clone;
9     }

改进后全部代码：

 1 import java.util.ArrayList;
 2 import java.util.Iterator;
 3 import java.util.List;
 4 import java.util.Vector;
 5 
 6 /**
 7  * Created by robin on 2016/5/11.
 8  *
 9  * @author robin
10  */
11 public class QuoteBugDemo {
12 
13     private static List<Integer> publicNums = new Vector<Integer>();
14 
15     public static void main(String args[]) throws InterruptedException {
16         initPublicNums();//初始化公共数据源
17 
18         timeTask(1);//模拟执行定时任务1
19 
20         timeTask(2);//模拟执行定时任务2
21 
22     }
23 
24 
25     private static void initPublicNums(){
26         for (int i =0;i < 10;i++){
27             publicNums.add(i);
28         }
29     }
30 
31     /**
32      * 改进方案1：获取公共数据源对象的副本
33      * shallow copy:list中 元素引用 仍然是相同的
34      * @return
35      */
36     private static List<Integer> getPublicNums(){
37         List<Integer> clone = new ArrayList<Integer>(publicNums);
38         return clone;
39     }
40 
41     /**
42      * 这块代码模拟的逻辑：
43      * 1.每天获取配置好10个的数据源；
44      * 2.检查这10个数据源，当数据源的数据准备好后，开始执行数据同步；
45      * 3.从当天的带同步数据源list删除已经同步的数据；
46      * @param mark
47      * @throws InterruptedException
48      */
49     private static void timeTask(int mark) throws InterruptedException {
50         final long start = System.currentTimeMillis();//程序开始运行时间
51         //每天待同步数据源
52         List<Integer> dataSources = getPublicNums();//改进方案1
53         StringBuffer sb = new StringBuffer("mark("+mark+");公共数据源数目:"+dataSources.size()+"；数据源列表[");
54         for (Integer i:dataSources){
55             sb.append(i+",");
56         }
57         sb.append("]");
58         System.out.println("日志【"+sb.toString()+"】");
59         while(true){
60             long seconds = (System.currentTimeMillis() - start) / 1000;
61             if(seconds > 15l){
62                 System.out.println("运行超过限定时间：15秒，退出");
63                 break;
64             }
65             Iterator<Integer> ite = dataSources.iterator();
66             while (ite.hasNext()){//
67                 int dataSource = ite.next();
68                 boolean flag = isOk(dataSource);
69                 if(flag){//数据源数据已准备好
70                     System.out.println("对数据源:"+dataSource+"进行数据处理。");//同步数据
71                     ite.remove();//待同步数据源删除该数据源
72                 }
73             }
74             if(dataSources.size() != 0){
75                 Thread.sleep(1000);
76             }else{
77                 break;
78             }
79         }
80         System.out.println("定时任务mark["+mark+"]已经执行完毕");
81     }
82 
83     /**
84      * 模拟检查数据源是否OK
85      * @param dataSource
86      * @return
87      */
88     private static boolean isOk(int dataSource){
89         if(dataSource%2 == 0){
90             return true;
91         }
92         return false;
93     }
94 
95 
96 }

执行结果：

 1 日志【mark(1);公共数据源数目:10；数据源列表[0,1,2,3,4,5,6,7,8,9,]】
 2 对数据源:0进行数据处理。
 3 对数据源:2进行数据处理。
 4 对数据源:4进行数据处理。
 5 对数据源:6进行数据处理。
 6 对数据源:8进行数据处理。
 7 运行超过限定时间：15秒，退出
 8 定时任务mark[1]已经执行完毕
 9 日志【mark(2);公共数据源数目:10；数据源列表[0,1,2,3,4,5,6,7,8,9,]】
10 对数据源:0进行数据处理。
11 对数据源:2进行数据处理。
12 对数据源:4进行数据处理。
13 对数据源:6进行数据处理。
14 对数据源:8进行数据处理。
15 运行超过限定时间：15秒，退出
16 定时任务mark[2]已经执行完毕