骐骏的博客

围绕国债逆回购与债基入门，介绍钱荒期货币ETF套利、逆回购期限与交易要点、债基分类、A/B/C份额费用、定开债选择、净值分红及债券指数基金特点。

从基金历史与分类切入，解析开放式和封闭式基金，重点介绍余额宝、货币基金的风险收益、费用及挑选方法，并梳理场内货币ETF交易规则与套利思路，帮助读者掌握基金理财基础。

从MyEclipse转向IDEA后，使用MyBatis生成器创建mapper时频繁报错。通过修改运行配置工作目录、调整依赖顺序，并取消provided作用域改用默认compile即可解决，同时回顾了Maven依赖范围。

使用线程池和阻塞队列构建多生产者与多消费者模型，生产者生成数据放入缓冲区，消费者循环取出处理，展示共享队列实现解耦、流量缓冲和异步消费的典型方式。

世界读书日之际，作者分享阅读坚持与三本书心得：分层主动阅读、实用书辨别与输出，管理精力以提升效能，识别拖延心理并借助目标、时间与习惯应对，倡导持续阅读。

Master-worker模式把并行任务拆为Master与Worker角色，Master负责接收、分配和汇总结果，Worker负责处理子任务并返回结果。文中以项目经理与开发人员类比，给出基于并发队列和线程的Java实现，并通过计算学生总成绩示例说明使用流程。

Future模式，如字面意思，就是要在将来的某个时刻获取到结果，有点类似于ES6中的Promise。

一个简单的栗子：

定义一个数据接口：

package com.fullstacker.study.designpattern.future;

public interface Data {

    String getRequest();

}

真实的数据加载类：

package com.fullstacker.study.designpattern.future;

public class RealData implements Data{

    private String result ;

    public RealData (String queryStr){
        System.out.println("根据\"" + queryStr + "\"进行查询，这是一个很耗时的操作..");
        try {
            Thread.sleep(5000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("耗时五秒,操作完毕，获取结果");
        result = "查询结果";
    }

    @Override
    public String getRequest() {
        return result;
    }

}

FutureData用于程序中使用“加载数据”，实现Future效果：

package com.fullstacker.study.designpattern.future;


public class FutureData implements Data{

    private RealData realData ;

    private boolean isReady = false;

    public synchronized void setRealData(RealData realData) {
        //如果已经装载完毕了，就直接返回
        if(isReady){
            return;
        }
        //如果没装载，进行装载真实对象
        this.realData = realData;
        isReady = true;
        //进行通知
        notify();
    }

    @Override
    public synchronized String getRequest() {
        //如果没装载好 程序就一直处于阻塞状态
        while(!isReady){
            try {
                wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        //装载好直接获取数据即可
        return this.realData.getRequest();
    }


}

查询FutureData

package com.fullstacker.study.designpattern.future;

public class FutureClient {

    public Data request(final String queryStr){
        //1 我想要一个代理对象（Data接口的实现类）先返回给发送请求的客户端，告诉他请求已经接收到，可以做其他的事情
        final FutureData futureData = new FutureData();
        //2 启动一个新的线程，去加载真实的数据，传递给这个代理对象
        new Thread(new Runnable() {
            @Override
            public void run() {
                //3 这个新的线程可以去慢慢的加载真实对象，然后传递给代理对象
                RealData realData = new RealData(queryStr);
                futureData.setRealData(realData);
            }
        }).start();

        return futureData;
    }

}

使用演示：

package com.fullstacker.study.designpattern.future;

public class Main {

    public static void main(String[] args) throws InterruptedException {

        FutureClient fc = new FutureClient();
        Data data = fc.request("这是一个参数");
        System.out.println("请求发送成功!");
        System.out.println("做其他的事情...");
        String result = data.getRequest();  
        System.out.println(result);

    }
}

运行main方法,打印结果

请求发送成功!
做其他的事情...
根据"这是一个参数"进行查询，这是一个很耗时的操作..
耗时五秒,操作完毕，获取结果
查询结果

调用FutureClient的request()方法，返回一个futureData实例，但是该实例并未加载真实的数据realData，而是通过子线程异步对realData赋值。main方法中当执行String result = data.getRequest(); 时由于还未得到真正的realData所以会一直等到数据真正加载完才能执行下面的打印。

jdk中有现成的Future模式接口FutureTask，使用示例如下：

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;
import java.util.concurrent.FutureTask;

public class UseFuture implements Callable<String>{
    private String para;

    public UseFuture(String para){
        this.para = para;
    }

    /**
     * 这里是真实的业务逻辑，其执行可能很慢
     */
    @Override
    public String call() throws Exception {
        //模拟执行耗时
        System.out.println("线程名："+ Thread.currentThread().getName());
        Thread.sleep(5000);
        String result = this.para + "处理完成";
        return result;
    }

    //主控制函数
    public static void main(String[] args) throws Exception {
        String queryStr = "query";
        //构造FutureTask，并且传入需要真正进行业务逻辑处理的类,该类一定是实现了Callable接口的类
        FutureTask<String> future = new FutureTask<String>(new UseFuture(queryStr));

        FutureTask<String> future2 = new FutureTask<String>(new UseFuture("task2222"));
        //创建一个固定线程的线程池且线程数为1,
        ExecutorService executor = Executors.newFixedThreadPool(2);
        //这里提交任务future,则开启线程执行RealData的call()方法执行
        //submit和execute的区别： 第一点是submit可以传入实现Callable接口的实例对象， 第二点是submit方法有返回值

        Future f1 = executor.submit(future);        //单独启动一个线程去执行的
        Future f2 = executor.submit(future2);
        System.out.println("请求完毕");

        try {
            //这里可以做额外的数据操作，也就是主程序执行其他业务逻辑
            System.out.println("处理实际的业务逻辑...");
            Thread.sleep(1000);
        } catch (Exception e) {
            e.printStackTrace();
        }
        //调用获取数据方法,如果call()方法没有执行完成,则依然会进行等待
        System.out.println("数据：" + future.get());
        System.out.println("数据：" + future2.get());

        executor.shutdown();
    }

}

2017年个人阅读书单按人文、科普IT、经济理财和技术分类整理，收录马东、李开复、黄仁宇、阮一峰等书籍并标注月份，呈现一年中跨领域学习与知识积累过程。

围绕单例模式展开，解析饿汉式、懒汉式、双重检测式与静态内部类等实现思路，说明线程安全、实例创建时机、锁粒度和初始化效率之间的关系及优化方法。

Java线程间通信通过wait、notify实现线程协作：调用wait释放锁并等待，notify唤醒等待线程。join方法可使一个线程等待另一线程执行完毕后再继续，从而将交叉执行转换为线性顺序执行。