java 之DelayQueue实际运用示例

梦里梦外; 2022-03-21 13:56 197阅读 0赞

# [java 之DelayQueue实际运用示例][java _DelayQueue] #

在学习Java 多线程并发开发过程中，了解到DelayQueue类的主要作用：是一个无界的BlockingQueue，用于放置实现了Delayed接口的对象，其中的对象只能在其到期时才能从队列中取走。这种队列是有序的，即队头对象的延迟到期时间最长。注意：不能将null元素放置到这种队列中。

**Delayed，**一种混合风格的接口，用来标记那些应该在给定延迟时间之后执行的对象。此接口的实现必须定义一个 compareTo 方法，该方法提供与此接口的 getDelay 方法一致的排序。

在网上也看到两个示例，但这两个示例个人在实际运行时均没有达到满足业务场景的效果，因而对其进行了修改，供大家参考讨论。

### 业务场景一：多考生考试 ###

该场景来自于[http://ideasforjava.iteye.com/blog/657384][http_ideasforjava.iteye.com_blog_657384]，模拟一个考试的日子，考试时间为120分钟，30分钟后才可交卷，当时间到了，或学生都交完卷了考试结束。

这个场景中几个点需要注意：

1.  考试时间为120分钟，30分钟后才可交卷，初始化考生完成试卷时间最小应为30分钟
2.  对于能够在120分钟内交卷的考生，如何实现这些考生交卷
3.  对于120分钟内没有完成考试的考生，在120分钟考试时间到后需要让他们强制交卷
4.  在所有的考生都交完卷后，需要将控制线程关闭

实现思想：用DelayQueue存储考生（Student类），每一个考生都有自己的名字和完成试卷的时间，Teacher线程对DelayQueue进行监控，收取完成试卷小于120分钟的学生的试卷。当考试时间120分钟到时，先关闭Teacher线程，然后强制DelayQueue中还存在的考生交卷。每一个考生交卷都会进行一次countDownLatch.countDown()，当countDownLatch.await()不再阻塞说明所有考生都交完卷了，而后结束考试。

![复制代码][copycode.gif]

package com.my.base.concurrent.delayQueue;
    
    import java.util.Iterator;
    import java.util.Random;
    import java.util.concurrent.CountDownLatch;
    import java.util.concurrent.DelayQueue;
    import java.util.concurrent.Delayed;
    import java.util.concurrent.TimeUnit;
    
    /**
     *this project is created for my partactice.
     *In the  project I will write the mybatis by myself
     *
     *2014-1-10  下午9:43:48
     *@author 孙振超   mychaoyue2011@163.com
     */
    
    public class Exam {
    
        /**
         *
         *2014-1-10 下午9:43:48 by 孙振超
         *
         *@param args
         *void
         * @throws InterruptedException 
         */
        public static void main(String[] args) throws InterruptedException {
            // TODO Auto-generated method stub
            int studentNumber = 20;
            CountDownLatch countDownLatch = new CountDownLatch(studentNumber+1);
            DelayQueue< Student> students = new DelayQueue<Student>();
            Random random = new Random();
            for (int i = 0; i < studentNumber; i++) {
                students.put(new Student("student"+(i+1), 30+random.nextInt(120),countDownLatch));
            }
            Thread teacherThread =new Thread(new Teacher(students)); 
            students.put(new EndExam(students, 120,countDownLatch,teacherThread));
            teacherThread.start();
            countDownLatch.await();
            System.out.println(" 考试时间到，全部交卷！");  
        }
    
    }
    
    class Student implements Runnable,Delayed{
    
        private String name;
        private long workTime;
        private long submitTime;
        private boolean isForce = false;
        private CountDownLatch countDownLatch;
        
        public Student(){}
        
        public Student(String name,long workTime,CountDownLatch countDownLatch){
            this.name = name;
            this.workTime = workTime;
            this.submitTime = TimeUnit.NANOSECONDS.convert(workTime, TimeUnit.NANOSECONDS)+System.nanoTime();
            this.countDownLatch = countDownLatch;
        }
        
        @Override
        public int compareTo(Delayed o) {
            // TODO Auto-generated method stub
            if(o == null || ! (o instanceof Student)) return 1;
            if(o == this) return 0; 
            Student s = (Student)o;
            if (this.workTime > s.workTime) {
                return 1;
            }else if (this.workTime == s.workTime) {
                return 0;
            }else {
                return -1;
            }
        }
    
        @Override
        public long getDelay(TimeUnit unit) {
            // TODO Auto-generated method stub
            return unit.convert(submitTime - System.nanoTime(),  TimeUnit.NANOSECONDS);
        }
    
        @Override
        public void run() {
            // TODO Auto-generated method stub
            if (isForce) {
                System.out.println(name + " 交卷, 希望用时" + workTime + "分钟"+" ,实际用时 120分钟" );
            }else {
                System.out.println(name + " 交卷, 希望用时" + workTime + "分钟"+" ,实际用时 "+workTime +" 分钟");  
            }
            countDownLatch.countDown();
        }
    
        public boolean isForce() {
            return isForce;
        }
    
        public void setForce(boolean isForce) {
            this.isForce = isForce;
        }
        
    }
    
    class EndExam extends Student{
    
        private DelayQueue<Student> students;
        private CountDownLatch countDownLatch;
        private Thread teacherThread;
        
        public EndExam(DelayQueue<Student> students, long workTime, CountDownLatch countDownLatch,Thread teacherThread) {
            super("强制收卷", workTime,countDownLatch);
            this.students = students;
            this.countDownLatch = countDownLatch;
            this.teacherThread = teacherThread;
        }
        
        
        
        @Override
        public void run() {
            // TODO Auto-generated method stub
            
            teacherThread.interrupt();
            Student tmpStudent;
            for (Iterator<Student> iterator2 = students.iterator(); iterator2.hasNext();) {
                tmpStudent = iterator2.next();
                tmpStudent.setForce(true);
                tmpStudent.run();
            }
            countDownLatch.countDown();
        }
        
    }
    
    class Teacher implements Runnable{
    
        private DelayQueue<Student> students;
        public Teacher(DelayQueue<Student> students){
            this.students = students;
        }
        
        @Override
        public void run() {
            // TODO Auto-generated method stub
            try {
                System.out.println(" test start");
                while(!Thread.interrupted()){
                    students.take().run();
                }
            } catch (Exception e) {
                // TODO: handle exception
                e.printStackTrace();
            }
        }
        
    }

![复制代码][copycode.gif]

### 业务场景二：具有过期时间的缓存 ###

该场景来自于[http://www.cnblogs.com/jobs/archive/2007/04/27/730255.html][http_www.cnblogs.com_jobs_archive_2007_04_27_730255.html]，向缓存添加内容时，给每一个key设定过期时间，系统自动将超过过期时间的key清除。

这个场景中几个点需要注意：

1.  当向缓存中添加key-value对时，如果这个key在缓存中存在并且还没有过期，需要用这个key对应的新过期时间
2.  为了能够让DelayQueue将其已保存的key删除，需要重写实现Delayed接口添加到DelayQueue的DelayedItem的hashCode函数和equals函数
3.  当缓存关闭，监控程序也应关闭，因而监控线程应当用守护线程

具体实现如下：

![复制代码][copycode.gif]

package com.my.base.concurrent.delayQueue;
    
    import java.util.Random;
    import java.util.concurrent.ConcurrentHashMap;
    import java.util.concurrent.DelayQueue;
    import java.util.concurrent.Delayed;
    import java.util.concurrent.TimeUnit;
    
    
    
    /**
     *Cache.java
     *
     * Created on 2014-1-11 上午11:30:36 by sunzhenchao mychaoyue2011@163.com
     */
    public class Cache<K, V> {
    
        public ConcurrentHashMap<K, V> map = new ConcurrentHashMap<K, V>();
        public DelayQueue<DelayedItem<K>> queue = new DelayQueue<DelayedItem<K>>();
        
        
        public void put(K k,V v,long liveTime){
            V v2 = map.put(k, v);
            DelayedItem<K> tmpItem = new DelayedItem<K>(k, liveTime);
            if (v2 != null) {
                queue.remove(tmpItem);
            }
            queue.put(tmpItem);
        }
        
        public Cache(){
            Thread t = new Thread(){
                @Override
                public void run(){
                    dameonCheckOverdueKey();
                }
            };
            t.setDaemon(true);
            t.start();
        }
        
        public void dameonCheckOverdueKey(){
            while (true) {
                DelayedItem<K> delayedItem = queue.poll();
                if (delayedItem != null) {
                    map.remove(delayedItem.getT());
                    System.out.println(System.nanoTime()+" remove "+delayedItem.getT() +" from cache");
                }
                try {
                    Thread.sleep(300);
                } catch (Exception e) {
                    // TODO: handle exception
                }
            }
        }
        
        /**
         * TODO
         * @param args
         * 2014-1-11 上午11:30:36
         * @author:孙振超
         * @throws InterruptedException 
         */
        public static void main(String[] args) throws InterruptedException {
            Random random = new Random();
            int cacheNumber = 10;
            int liveTime = 0;
            Cache<String, Integer> cache = new Cache<String, Integer>();
            
            for (int i = 0; i < cacheNumber; i++) {
                liveTime = random.nextInt(3000);
                System.out.println(i+"  "+liveTime);
                cache.put(i+"", i, random.nextInt(liveTime));
                if (random.nextInt(cacheNumber) > 7) {
                    liveTime = random.nextInt(3000);
                    System.out.println(i+"  "+liveTime);
                    cache.put(i+"", i, random.nextInt(liveTime));
                }
            }
    
            Thread.sleep(3000);
            System.out.println();
        }
    
    }
    
    class DelayedItem<T> implements Delayed{
    
        private T t;
        private long liveTime ;
        private long removeTime;
        
        public DelayedItem(T t,long liveTime){
            this.setT(t);
            this.liveTime = liveTime;
            this.removeTime = TimeUnit.NANOSECONDS.convert(liveTime, TimeUnit.NANOSECONDS) + System.nanoTime();
        }
        
        @Override
        public int compareTo(Delayed o) {
            if (o == null) return 1;
            if (o == this) return  0;
            if (o instanceof DelayedItem){
                DelayedItem<T> tmpDelayedItem = (DelayedItem<T>)o;
                if (liveTime > tmpDelayedItem.liveTime ) {
                    return 1;
                }else if (liveTime == tmpDelayedItem.liveTime) {
                    return 0;
                }else {
                    return -1;
                }
            }
            long diff = getDelay(TimeUnit.NANOSECONDS) - o.getDelay(TimeUnit.NANOSECONDS);
            return diff > 0 ? 1:diff == 0? 0:-1;
        }
    
        @Override
        public long getDelay(TimeUnit unit) {
            return unit.convert(removeTime - System.nanoTime(), unit);
        }
    
        public T getT() {
            return t;
        }
    
        public void setT(T t) {
            this.t = t;
        }
        @Override
        public int hashCode(){
            return t.hashCode();
        }
        
        @Override
        public boolean equals(Object object){
            if (object instanceof DelayedItem) {
                return object.hashCode() == hashCode() ?true:false;
            }
            return false;
        }
        
    }

![复制代码][copycode.gif]

[![clipboard][]][clipboard 1]

分类: [Java基础][Java]

标签: [Java][Java 1], [Delayed][], [DelayQueue][], [CountDownLatch][]

好文要顶 关注我 收藏该文 ![icon_weibo_24.png][] ![wechat.png][]

[![sample_face.gif][]][sample_face.gif 1]

[孙振超][sample_face.gif 1]  
[关注 - 6][- 6]  
[粉丝 - 102][- 102]

\+加关注

[« ][Link 1]上一篇：[JVM之---垃圾回收][Link 1]  
[» ][Link 2]下一篇：[CDN和镜像站点比较][Link 2]

posted on 2014-01-11 16:21 [孙振超][Link 3] 阅读(31146) 评论(27) [编辑][Link 4] [收藏][Link 5]

**评论:**[\#1楼][1] 2015-08-24 16:25 | [snowwolf101][] [ ][Link 6]

写的非常不错啊 谢谢楼主的总结

支持(0)反对(0)

[\#2楼][2] 2015-09-19 22:57 | [龙戏天][Link 7] [ ][Link 8]

this.submitTime = TimeUnit.NANOSECONDS.convert(workTime, TimeUnit.NANOSECONDS)+System.nanoTime();  
这个时间转化没用。

支持(0)反对(0)

[\#3楼][3] 2016-03-27 20:56 | [被罚站的树][Link 9] [ ][Link 10]

mark!

支持(0)反对(0)

[\#4楼][4] 2016-07-13 14:18 | [Eric Lan][] [ ][Link 11]

nice job and a lot help for me!

支持(0)反对(0)

[\#5楼][5] 2016-12-02 16:20 | [李鸿远][Link 12] [ ][Link 13]

好坑的一篇文章，为了指出楼主的错误，专门注册了一个账号。  
问题1，既然是根据失效时间来判断出栈，怎么能用livetime，如果live时间是一样的，中间我删除了几个元素再加入几个元素，livetime都是一样的，顺序就乱了。需要用removeTime判断。  
问题2，为何要重写equals，如果我中间删除一个元素，再加入一个元素，key是一样的，之前我删除的那个元素，时间到了，仍然会take出来。  
问题3:，while(true)里面应该用take方法，大负载下poll会造成cpu过高。

支持(3)反对(0)

[\#6楼][6]\[楼主\] 2016-12-05 16:48 | [孙振超][Link 3] [ ][Link 14]

[@][5] 李鸿远  
非常难得！！  
有换工作的计划吗？

支持(0)反对(0)

[\#7楼][7] 2016-12-05 18:22 | [李鸿远][Link 12] [ ][Link 13]

[@][6] 孙振超  
哈哈 谢谢  
你要是西安的就考虑

支持(0)反对(0)

[\#8楼][8]\[楼主\] 2016-12-15 12:20 | [孙振超][Link 3] [ ][Link 14]

[@][7] 李鸿远  
哎，我这边是在北京。有在北京的同学或者朋友可以推荐，我们这边是java服务端，有不少牛人，要处理每秒几十万的请求。

支持(0)反对(0)

[\#9楼][9] 2016-12-19 11:05 | [李鸿远][Link 15] [ ][Link 13]

[@][8] 孙振超  
北上广还是领先呀，我们很少有这样的机会处理这么多请求。  
首先光这网络带宽都不是一般用户负担的起的，你们使用弹性计算了吗，就是自动扩容？

支持(0)反对(0)

[\#10楼][10]\[楼主\] 2017-01-04 11:15 | [孙振超][Link 3] [ ][Link 14]

[@][9] 李鸿远  
有一个管理平台，可以设置cpu使用上限多少扩容多少机器，cpu使用下限多少缩容多少机器。配置好后会自动进行处理。

支持(0)反对(0)

[\#11楼][11] 2017-02-26 23:45 | [leon66666][] [ ][Link 16]

对于场景一。有一些不同的观点。  
首先，宣布考试结束和强制收试卷这些事情由老师线程来处理更加的符合实际。而不应该终止老师线程。  
其次，两个类能实现的场景。却使用了三个类，涉及到了继承关系，增加了复杂度，违背了基本的设计原则。  
最后，我在您的基础上进行了改造，去除了EndExam类和countDownLatch，这些都封装到了teacher类中。  
源码放到了[这里][Link 17]。说的不对的地方欢迎批评指正

支持(0)反对(0)

[\#12楼][12] 2017-03-01 08:34 | [举个栗子][Link 18] [ ][Link 19]

谢楼主总结。参考实现了一个模拟Session的应用场景  
[http://blog.csdn.net/soonfly/article/details/58599087][http_blog.csdn.net_soonfly_article_details_58599087]

支持(0)反对(0)

[\#13楼][13]\[楼主\] 2017-03-06 16:09 | [孙振超][Link 3] [ ][Link 14]

[@][11] 王中秋  
hi,请问你在哪里工作啊？如果有大并发量的应用场景、有可以和行业技术高手共事的机会 可能换工作吗？

支持(0)反对(0)

[\#14楼][14] 2017-03-14 19:00 | [leon66666][] [ ][Link 16]

[@][13] 孙振超  
目前在朝阳区望京附近工作，金融行业。很乐意进一步的了解一下贵公司

支持(0)反对(0)

[\#15楼][15] 2017-03-22 18:06 | [雾和狼][Link 20] [ ][Link 21]

this.submitTime = TimeUnit.NANOSECONDS.convert(workTime, TimeUnit.NANOSECONDS)+System.nanoTime();  
应该是  
this.submitTime = TimeUnit.NANOSECONDS.convert(workTime, **TimeUnit.MINUTES**)+System.nanoTime();  
单位用错了吧，submitTime的单位不是分钟吗

支持(0)反对(0)

[\#16楼][16] 2017-04-11 10:05 | [杉木的征途][Link 22] [ ][Link 23]

@王中秋   
你的程序有问题，如果现在时间不是毫微妙，你的程序就会有问题，因为 Student student = students.poll();并没有保证student为null啊。可以使用take方法，我将时间改为秒，你的程序就出问题了，此为拙见。

支持(2)反对(0)

[\#17楼][17] 2017-08-24 19:05 | [荐辕][Link 24] [ ][Link 25]

DelayedItem<K> tmpItem = new DelayedItem<K>(k, liveTime);  
if (v2 != null) \{  
queue.remove(tmpItem);  
\}  
这段代码有问题。原因在于：  
1. 重写hashcode不应重写equals方法，原因上面有人已经说明。  
2. 如果不重写equals方法，那么上面从queue中删除tmpItem的方法也不对。新new出来的对象，和原来的DelayedItem物理地址不同，调用Object基类的equals方法也不可能删掉。  
3. hashCode方法可能引发潜在问题。如果是根据t.hashCode来确定DelayedItem的hash值，但是DelayedItem中同时由set(T t)方法会动态改变hash值。若将DelayedItem存在HashSet等集合当中，容易引发内存泄漏无法GC对象。

支持(1)反对(0)

[\#18楼][18] 2017-08-24 19:23 | [荐辕][Link 24] [ ][Link 25]

另外还存在一个问题。  
多线程环境中。假设dameonCheckOverdueKey线程在执行if (delayedItem != null) 判断之后，另一个线程更新了map缓存中key值对应的value。然后map.remove(delayedItem.getT())。这会导致最近put进去的缓存丢失。问题不是很严重，但是缓存系统应该充分考虑到这种情况。  
建议这部分代码加上多线程同步控制。

支持(0)反对(1)

[\#19楼][19]\[楼主\] 2017-09-10 16:16 | [孙振超][Link 3] [ ][Link 14]

[@][17] 荐辕  
顶！d=====(￣▽￣\*)b

支持(0)反对(0)

[\#20楼][20] 2018-04-25 14:00 | [承载][Link 26] [ ][Link 27]

[@][11] leon66666  
你写的代码是有错误的，你添加的是6个人。。。学生编号只有5个。你可以多运行几次，肯定会有一个学生叫student 这是不对的。

支持(0)反对(0)

[\#21楼][21] 2018-04-25 14:02 | [承载][Link 26] [ ][Link 27]

students.put(new EndExam(students, 120,countDownLatch,teacherThread));为什么要多加一个人。

支持(0)反对(0)

[\#22楼][22] 2018-05-31 11:20 | [wumc\_time][wumc_time] [ ][Link 28]

[@][16] 杉木的征途  
改为秒后，pool老拿的是头部元素，意味着很多后面不达到强制交卷的都被迫交卷了(也就是部分提前交卷的生生被搞成被迫交卷了

支持(0)反对(0)

[\#23楼][23] 2018-05-31 11:28 | [wumc\_time][wumc_time] [ ][Link 28]

[@][18] 荐辕  
ConcurrentHashMap

支持(0)反对(0)

[\#24楼][24] 2018-07-21 15:35 | [林冲—first][first] [ ][Link 29]

第一个场景的代码Studnet不是根据getdelay()来进行排序的，实现了compareable接口利用workTimke来进行排序，submitTime这个没啥用，getdelay（）直接返回零也没关系，这样容易误导读者

支持(0)反对(0)

[\#25楼][25] 2018-11-15 09:42 | [林雪莲][Link 30] [ ][Link 31]

[@][17] 荐辕  
为啥不能重写equals方法 能不能解释下？这点没明白

支持(0)反对(0)

[\#26楼][26] 2018-11-15 09:43 | [林雪莲][Link 30] [ ][Link 31]

[@][5] 李鸿远  
问题2没明白 能否解释一下

支持(0)反对(0)

[\#27楼][27] 2019-01-29 15:57 | [zhO][] [ ][Link 32]

重写的DelayedItem<T>的equals方法应该比较T(key)是否一样。

[java _DelayQueue]: https://www.cnblogs.com/sunzhenchao/p/3515085.html
[http_ideasforjava.iteye.com_blog_657384]: http://ideasforjava.iteye.com/blog/657384
[copycode.gif]: /images/20220321/781ff7c17ef14649bf7c29a0c0a29a08.png
[http_www.cnblogs.com_jobs_archive_2007_04_27_730255.html]: http://www.cnblogs.com/jobs/archive/2007/04/27/730255.html
[clipboard]: /images/20220321/f7295f2d84db4b20bbea6dc92cea6228.png
[clipboard 1]: https://images0.cnblogs.com/blog/330894/201401/111617138482.png
[Java]: https://www.cnblogs.com/sunzhenchao/category/435052.html
[Java 1]: https://www.cnblogs.com/sunzhenchao/tag/Java/
[Delayed]: https://www.cnblogs.com/sunzhenchao/tag/Delayed/
[DelayQueue]: https://www.cnblogs.com/sunzhenchao/tag/DelayQueue/
[CountDownLatch]: https://www.cnblogs.com/sunzhenchao/tag/CountDownLatch/
[icon_weibo_24.png]: https://common.cnblogs.com/images/icon_weibo_24.png
[wechat.png]: /images/20220321/4afa9405401744acb12add44507c7bf9.png
[sample_face.gif]: /images/20220321/9ac8ba17292b4bc88e8f5e6f84960baa.png
[sample_face.gif 1]: http://home.cnblogs.com/u/sunzhenchao/
[- 6]: http://home.cnblogs.com/u/sunzhenchao/followees
[- 102]: http://home.cnblogs.com/u/sunzhenchao/followers
[Link 1]: https://www.cnblogs.com/sunzhenchao/p/3484217.html
[Link 2]: https://www.cnblogs.com/sunzhenchao/p/3586442.html
[Link 3]: https://www.cnblogs.com/sunzhenchao/
[Link 4]: https://i.cnblogs.com/EditPosts.aspx?postid=3515085
[Link 5]: https://www.cnblogs.com/sunzhenchao/p/3515085.html#
[1]: https://www.cnblogs.com/sunzhenchao/p/3515085.html#3253231
[snowwolf101]: https://www.cnblogs.com/mrzhang123/
[Link 6]: http://msg.cnblogs.com/send/snowwolf101
[2]: https://www.cnblogs.com/sunzhenchao/p/3515085.html#3270104
[Link 7]: https://www.cnblogs.com/shalf/
[Link 8]: http://msg.cnblogs.com/send/%E9%BE%99%E6%88%8F%E5%A4%A9
[3]: https://www.cnblogs.com/sunzhenchao/p/3515085.html#3392989
[Link 9]: https://www.cnblogs.com/xidongyu/
[Link 10]: http://msg.cnblogs.com/send/%E8%A2%AB%E7%BD%9A%E7%AB%99%E7%9A%84%E6%A0%91
[4]: https://www.cnblogs.com/sunzhenchao/p/3515085.html#3469263
[Eric Lan]: https://www.cnblogs.com/ijavanese/
[Link 11]: http://msg.cnblogs.com/send/Eric%20Lan
[5]: https://www.cnblogs.com/sunzhenchao/p/3515085.html#3570984
[Link 12]: http://home.cnblogs.com/u/1074074/
[Link 13]: http://msg.cnblogs.com/send/%E6%9D%8E%E9%B8%BF%E8%BF%9C
[6]: https://www.cnblogs.com/sunzhenchao/p/3515085.html#3572744
[Link 14]: http://msg.cnblogs.com/send/%E5%AD%99%E6%8C%AF%E8%B6%85
[7]: https://www.cnblogs.com/sunzhenchao/p/3515085.html#3572882
[8]: https://www.cnblogs.com/sunzhenchao/p/3515085.html#3581413
[9]: https://www.cnblogs.com/sunzhenchao/p/3515085.html#3584244
[Link 15]: https://www.cnblogs.com/lihongyuan/
[10]: https://www.cnblogs.com/sunzhenchao/p/3515085.html#3595903
[11]: https://www.cnblogs.com/sunzhenchao/p/3515085.html#3627054
[leon66666]: https://www.cnblogs.com/wangzhongqiu/
[Link 16]: http://msg.cnblogs.com/send/leon66666
[Link 17]: http://www.cnblogs.com/wangzhongqiu/p/6461880.html
[12]: https://www.cnblogs.com/sunzhenchao/p/3515085.html#3628852
[Link 18]: https://www.cnblogs.com/soonfly/
[Link 19]: http://msg.cnblogs.com/send/%E4%B8%BE%E4%B8%AA%E6%A0%97%E5%AD%90
[http_blog.csdn.net_soonfly_article_details_58599087]: http://blog.csdn.net/soonfly/article/details/58599087
[13]: https://www.cnblogs.com/sunzhenchao/p/3515085.html#3633018
[14]: https://www.cnblogs.com/sunzhenchao/p/3515085.html#3640595
[15]: https://www.cnblogs.com/sunzhenchao/p/3515085.html#3648728
[Link 20]: http://home.cnblogs.com/u/1132039/
[Link 21]: http://msg.cnblogs.com/send/%E9%9B%BE%E5%92%8C%E7%8B%BC
[16]: https://www.cnblogs.com/sunzhenchao/p/3515085.html#3664937
[Link 22]: https://www.cnblogs.com/shanmu/
[Link 23]: http://msg.cnblogs.com/send/%E6%9D%89%E6%9C%A8%E7%9A%84%E5%BE%81%E9%80%94
[17]: https://www.cnblogs.com/sunzhenchao/p/3515085.html#3765704
[Link 24]: http://home.cnblogs.com/u/1225992/
[Link 25]: http://msg.cnblogs.com/send/%E8%8D%90%E8%BE%95
[18]: https://www.cnblogs.com/sunzhenchao/p/3515085.html#3765713
[19]: https://www.cnblogs.com/sunzhenchao/p/3515085.html#3779918
[20]: https://www.cnblogs.com/sunzhenchao/p/3515085.html#3960734
[Link 26]: https://www.cnblogs.com/wpfxl/
[Link 27]: http://msg.cnblogs.com/send/%E6%89%BF%E8%BD%BD
[21]: https://www.cnblogs.com/sunzhenchao/p/3515085.html#3960735
[22]: https://www.cnblogs.com/sunzhenchao/p/3515085.html#3987379
[wumc_time]: http://home.cnblogs.com/u/625170/
[Link 28]: http://msg.cnblogs.com/send/wumc_time
[23]: https://www.cnblogs.com/sunzhenchao/p/3515085.html#3987397
[24]: https://www.cnblogs.com/sunzhenchao/p/3515085.html#4025485
[first]: https://www.cnblogs.com/linchongatfirst/
[Link 29]: http://msg.cnblogs.com/send/%E6%9E%97%E5%86%B2%E2%80%94first
[25]: https://www.cnblogs.com/sunzhenchao/p/3515085.html#4114799
[Link 30]: http://home.cnblogs.com/u/1536410/
[Link 31]: http://msg.cnblogs.com/send/%E6%9E%97%E9%9B%AA%E8%8E%B2
[26]: https://www.cnblogs.com/sunzhenchao/p/3515085.html#4114802
[27]: https://www.cnblogs.com/sunzhenchao/p/3515085.html#4173650
[zhO]: http://home.cnblogs.com/u/529681/
[Link 32]: http://msg.cnblogs.com/send/zhO