android多线程之线程池

一.线程简介

在Android应用开发中在进行耗时操作时，此时就要用到线程，由于UI线程不能进行耗时操作，否则就会造成ANR，话不多说下面直接干货。

二.子线程中更新UI的原理

有时在子线程中执行完操作以后需要把结果回传到UI线程，但是由于异步操作，我们需要等待子线程执行完毕之后才更新UI，这时大家都会想到Handler ，Message这种消息传递机制进行线程的切换，

其中的源码我在这里不再的分析，但是线程切换最本质的地方如下代码：

new Thread(new Runnable() {
@Override
public void run() {
Looper looper = Looper.getMainLooper()
looper.prepare();
//执行UI操作
looper.loop();
}
}).start();

其实Handle 消息机制最本质的就是利用Looper实现线程切换。

三.与多线程有关的方法

1.Callable

2.Future

3.FutureTask

4.Runnable

Runnable 在多线程中是最熟悉不过的，但是Runnable 和Future 可以应用在Thread中，而Callable和Future只能应用在线程中。下面看代码：

Runnable 接口

public interface Runnable {
void run();
}

Runnable接口没有返回值

Callable 接口

public interface Callable<V> {
V call() throws Exception;
}

Callable 接口与Runnable接口不同的是一个泛型接口，它有一个泛型V的call()方法的返回值，而Runnable里面的run()方法执行完没有返回值；

Future接口

public interface Future<V> {
boolean cancel(boolean var1);
//该任务是否取消
boolean isCancelled();

//该任务是否执行完成
boolean isDone();

//得到返回结果，会发生阻塞
V get() throws InterruptedException, ExecutionException;

V get(long var1, TimeUnit var3) throws InterruptedException, ExecutionException, TimeoutException;
}

相比于Callable 和Runnable ,Future提供了对执行任务的可控性，这样很大程度上方便对执行任务的操作。

FutureTask 类

public class FutureTask<V> implements RunnableFuture<V> {
//代码省略
}

public interface RunnableFuture<V> extends Runnable, Future<V> {
void run();
}

FutureTask 实现了Runnable，这就是为什么他能应用于Thread中，下面我们通过一个例子来说明他们的区别！

public class FutureDemo {

static ExecutorService mExecutor = Executors.newSingleThreadExecutor();

public static void main(String[] args){
testRunnable();
testCallable();
testFutureTask();

}

private static void testFutureTask() {
FutureTask<Integer> futureTask = new FutureTask<Integer>(new Callable<Integer>() {
@Override
public Integer call() throws Exception {
return sum(5, 16);
}
});
mExecutor.submit(futureTask);
try {
System.out.println("=========testFutureTask====="+futureTask.get());
} catch (Exception e) {
e.printStackTrace();
}
}

private static void testCallable() {
Future<Integer> submit = mExecutor.submit(new Callable<Integer>() {
@Override
public Integer call() throws Exception {
return sum(5, 16);
}
});
try {
System.out.println("=========testCallable====="+submit.get());
} catch (Exception e) {
e.printStackTrace();
}
}

private static void testRunnable() {
Future<?> submit = mExecutor.submit(new Runnable() {
@Override
public void run() {
sum(5, 16);
}
});
try {
System.out.println("=========testRunnable====="+submit.get());
} catch(Exception e) {
e.printStackTrace();
}
}

private static int sum(int a, int b){
return a+b;
}
}

下附输出结果

=========testRunnable=====null
=========testCallable=====21
=========testFutureTask=====21

通过这个demo正好验证上面的结果。

四.Android中的线程池

1.常规线程池

直接上代码

public class ThreadManager {
//线程池中线程数
private final int THREAD_FIXED = 10;
//单例模式获取对象
private static ThreadManager sInstance = null;
//线程池
private ExecutorService mExecutorService;

private ThreadManager() {
this.mExecutorService = Executors.newFixedThreadPool(THREAD_FIXED);
}

public static synchronized ThreadManager getInstance() {
if (sInstance == null) {
sInstance = new ThreadManager();
}

c9f0
return sInstance;
}
//执行操作任务接口
public void submit(Runnable task) {
this.mExecutorService.submit(task);
}

public Future<Integer> submit(Callable<Integer> task) {
return this.mExecutorService.submit(task);
}

//关闭执行任务
public void shutdown() {
if (!this.mExecutorService.isShutdown())
this.mExecutorService.shutdownNow();
}
}

2.阻塞线程池

利用生产者和消费者模式来实现，并加上拒绝策略实现阻塞。直接上代码。

public class ThreadPoolManager {

//核心线程数
private int corePoolSize = 4;
//最大线程数
private int maximumPoolSize = 10;
//保持时间
private long keepAliveTime =10;
//时间单位
private TimeUnit unit = TimeUnit.SECONDS;
//阻塞线程队列
private LinkedBlockingQueue<Runnable> workQueue =  new LinkedBlockingQueue<>();

/**
* 线程池，执行请求
*/
private ThreadPoolExecutor threadPoolExecutor;

private ThreadPoolManager(){
this.threadPoolExecutor = new ThreadPoolExecutor(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue, handler);
//开启请求对列
threadPoolExecutor.submit(runnable);
}

public static ThreadPoolManager getInstance(){
return InstanceHolder.instance;
}

private static class InstanceHolder{
private static ThreadPoolManager instance = new ThreadPoolManager();
}

/**
* 暴露api，添加请求
*/
public <T> void excute(FutureTask<T> futureTask){
if(null != futureTask){
try {
workQueue.put(futureTask);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}

private Runnable runnable = new Runnable() {
@Override
public void run() {
while(true){
FutureTask futureTask = null;
try {
//阻塞就在这里
futureTask = (FutureTask) workQueue.take();

} catch (InterruptedException e) {
e.printStackTrace();
}finally {
//执行请求
if(null != futureTask){
threadPoolExecutor.execute(futureTask);
}
}

}
}
};
/**
* 拒绝策略，实现队列阻塞
*/
private RejectedExecutionHandler handler = new RejectedExecutionHandler() {
@Override
public void rejectedExecution(Runnable runnable, ThreadPoolExecutor threadPoolExecutor) {
try {
workQueue.put(new FutureTask<Object>(runnable,null));
} catch (InterruptedException e) {
e.printStackTrace();
}

}
};

}

下面是调用方法

ThreadPoolManager.getInstance().excute(new FutureTask<Object>(new Callable<Object>() {
@Override
public Object call() throws Exception {

return null;
}
}));

执行流程如下：

1.创建ThreadPoolManager单例对象；

2.在构造方法里面就创建线程并且执行任务Runnable

3.Runnable里面就从队列里面取出任务，最后执行任务

4.excute()方法就是往队列里面添加任务.

到此android的线程池分析完毕；

逆风的方向，更适合飞翔