android利用线程池进行并行计算加速并且返回计算结果

这个方法适合大量数据比对，或者单次计算互不影响的情况

线程池之前用过，但其实没有遇到过大量计算时候，还是没有进行过深入的了解和比较，正好，这次需要用到多线程并行计算并且同时返回计算结果的这么一个需求，网上找了一大圈，可能是搜索方式不对吧，相应的介绍比较少，大多都是无返回结果的并行计算，后来找到了对应方法，但是，写法不对的话是会用坑的

这里我就简单介绍一下，关于利用线程池，进行多线程并行计算并且返回结果的简单例子

package com.lake.threadtest;

import android.support.v7.app.AppCompatActivity;
import android.os.Bundle;
import android.util.Log;
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.Callable;
import java.util.concurrent.Future;

public class MainActivity extends AppCompatActivity {

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        TestThreadPool.initTestThreadPool();

        try {
            runTestRunnable();
        } catch (Exception e) {
            e.printStackTrace();
        }

    }

    public List<Integer> runTestRunnable() throws Exception {
        List<Future<Integer>> list = new ArrayList<>();
        List<Integer> list1 = new ArrayList<>();
        for (int i = 0; i < 10; i++) {
            Future<Integer> future = TestThreadPool.post(new testRunnable(i));
            list.add(future);//返回值先存进去别取
        }
        //future.get()这个方法有坑，因为get这个方法是阻塞的，所以，需要以上线程调用完了，再单独取值，不然，你直接在上面for循环里get的话，线程执行就会被阻塞
        for (Future<Integer> future : list) {
            Log.e("lake", "执行结果=" + future.get());//这里单独取
            list1.add(future.get());
        }
        return list1;
    }
	//平时都用runnable，但是你需要返回值时候，那么就得用callable
    public class testRunnable implements Callable<Integer> {
        private int i;

        public testRunnable(int i) {
            this.i = i;
        }

        @Override
        public Integer call() throws Exception {
            Log.e("lake", "执行" + i);
            Thread.sleep(2000);
            Log.e("lake", "执行完成" + i);
            return i;
        }
    }
}

对应的线程池类

package com.lake.threadtest;

import android.util.Log;

import java.util.concurrent.BlockingQueue;
import java.util.concurrent.Callable;
import java.util.concurrent.Future;
import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

public class TestThreadPool {
    private static TestThreadPool mInstance;
    private ThreadPoolExecutor mThreadPoolExec;
    private static int MAX_POOL_SIZE;
    private static final int KEEP_ALIVE = 10;
    BlockingQueue<Runnable> workQueue = new LinkedBlockingQueue<>();
	//初始化一个自定义线程池
    public static synchronized void initTestThreadPool() {
        if (mInstance == null) {
            mInstance = new TestThreadPool();
        }
    }

    public static Future<Integer> post(Callable<Integer> runnable){
        Future<Integer> taskFuture = mInstance.mThreadPoolExec.submit(runnable);
        return taskFuture;
    }


    private TestThreadPool() {
        int coreNum = Runtime.getRuntime().availableProcessors();//核心线程数
        Log.e("lake", "cpu核心数=" + coreNum);
        MAX_POOL_SIZE = coreNum + 1;//线程池大小
        mThreadPoolExec = new ThreadPoolExecutor(
                coreNum,
                MAX_POOL_SIZE,
                KEEP_ALIVE,
                TimeUnit.SECONDS,
                workQueue);
    }

    public static void finish() {//中断线程池执行队列
        mInstance.mThreadPoolExec.shutdown();
    }
}

以上就是简单的带返回值的并行计算的例子，自测的结果是，多线程数量为核心线程数时候，能达到最优的加速，大概能比原来的计算耗时缩减至原来的3/8的样子，计算量小的话，没有什么效果