并行程序开发及优化

对于多核CPU，传统的串行程序已经无法很好的发挥CPU的性能。这就需要通过多线程的方式挖掘CPU的潜能

1、并行程序设计模式

并行设计模式是对一些常用的多线程结构的总结和抽象

1.1 Future模式

核心是去除了主线程中的等待时间，在这个等待时间内可以去处理其他的业务逻辑

下面通过自实现的简单函数来模拟Future的原理

Data接口

package XingNeng.future.test;

/**
 *Data
 */
public interface Data {
    /**
     * String
     * @return String
     */
     String getResult();
}

FutureData类

package XingNeng.future.test;

public class FutureData implements Data {
    protected RealData realdata = null;
    protected boolean isReady = false;

    /**
     * @param realdata
     */
    public synchronized void setRealData(RealData realdata) {
        if (isReady) {
            return;
        }
        this.realdata = realdata;
        isReady = true;
        notifyAll();
    }

    /**
     * @return
     */
    public synchronized String getResult() {
        while (!isReady) {
            System.out.println("isReady " + isReady);
            try {
                wait();
            } catch (InterruptedException e) {
            }
        }
        return realdata.result;
    }
}

RealData 类

package XingNeng.future.test;

public class RealData implements Data {
    protected final String result;

    /**
     * @param para
     */
    public RealData(String para) {
        StringBuffer sb = new StringBuffer();
        for (int i = 0; i < 10; i++) {
            sb.append(para);
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
            }
        }
        result = sb.toString();
    }

    public String getResult() {
        return result;
    }
}

Client的实现

package XingNeng.future.test;

public class Client {
    public Data request(final String queryStr) {
        final FutureData future = new FutureData();

        new Thread() {                                      
            public void run() {                             
                RealData realdata = new RealData(queryStr);
                future.setRealData(realdata);
            }                                               
        }.start();
        return future;
    }
}

Main的实现

package XingNeng.future.test;

public class Main {
    public static void main(String[] args) {
        Client client = new Client();

        Data data = client.request("a");
        System.out.println("发送请求成功");

        long start = System.currentTimeMillis();
        System.out.println("尝试获取真实数据 " + data.getResult());
        long end = System.currentTimeMillis();
        System.out.println(end - start);
        try {
            Thread.sleep(2000);
        } catch (InterruptedException e) {
        }

        System.out.println("真实数据 " + data.getResult());
    }
}

输出结果

1.2 Master-Worker模式

Master-Worker模式是将串行任务并行化的方法，被分解的子任务在系统中并行处理。如果需要，Master可以不等到所有worker完成就可以返回结果。

Master进程为主要进程，维护了worker线程队列、任务队列及子结果集。

简单示例代码：

Worker

package XingNeng.materwrk;

import java.util.Map;
import java.util.Queue;

public class Worker implements Runnable {
    protected Queue