前言
大家好,我是小墨,be foolish,be hungry。本篇文章主要写redis的集群方案相关知识,欢迎大家多多斧正,如果觉得小墨我写得用心的话,可以点个赞啊。
对异步线程比较感兴趣,所以这章将通过讲解future使用方法,阅读futureTask源码,进行异步学习,后面会出一篇博客写异步进阶—completableFuture学习
参考文章:https://www.jianshu.com/p/43dab9b7c25b
一,future futureTask类
FutureTask 是 future的实现类
futureTask方法实现RunnableFuture接口,RunnableFuture接口又继承runnable future接口,我们又看到FutureTask(Callable)构造器,所以FutureTask普遍使用方法是包装Callable接口,扔给Runnable接口作为Thread来运行
二,future代码使用
futureTask有两个构造器
FutureTask(Callable callable)
FutureTask(Runnable runnable, V result) 基本常用第一个
long startTime = System.currentTimeMillis();
//线程池执行
ExecutorService executorService = Executors.newCachedThreadPool();
FutureTask<Integer> task1 = new FutureTask<Integer>(new Callable<Integer>() {
public Integer call() throws Exception {
Thread.sleep(3000);
return 5;
}
});
executorService.execute(task1);
//thread start
FutureTask<Integer> task2 = new FutureTask<Integer>(new Callable<Integer>() {
public Integer call() throws Exception {
Thread.sleep(3000);
return 3;
}
});
new Thread(task2).start();
int i1 = task1.get();
int i2 = task2.get();
long endTime = System.currentTimeMillis();
System.out.println(i1+i2);
System.out.println("耗时:"+String.valueOf(endTime-startTime));
会发现两个线程运行后阻塞在get()方法,然后你可以拿到这两个值,我计时发现基本在3000ms,所以这个其实支持在线程池中同时invokeAll所有任务,这里使用有返回值的callable。
cancel(boolean):
1、任务还没开始,返回false
2、任务已经启动,cancel(true),中断正在运行的任务,协作式中断,返回true,cancel(false),不会去中断已经运行的任务
3、任务已经结束,返回false
三,future原理讲解
这一章节我们深入futureTask这个future的实现类去查看异步实现逻辑。
在这查看源码时我们会遇到UNSAFE类,该类提供一些直接使用cas方法去修改内存值,我们先简单介绍下futureTask类的一些状态值
private static final long stateOffset;//状态相对内存地址偏移值
private static final long runnerOffset;//线程相对内存地址偏移值
//waiters是futureTask类维护的一个存放等待线程的栈数据结构
private static final long waitersOffset;//线程栈相对内存地址偏移值
static {
try {
UNSAFE = sun.misc.Unsafe.getUnsafe();
Class<?> k = FutureTask.class;
stateOffset = UNSAFE.objectFieldOffset
(k.getDeclaredField("state"));
runnerOffset = UNSAFE.objectFieldOffset
(k.getDeclaredField("runner"));
waitersOffset = UNSAFE.objectFieldOffset
(k.getDeclaredField("waiters"));
} catch (Exception e) {
throw new Error(e);
}
}
通过该静态类先告诉我们这三个值在内存具体地址,然后可以直接采用cas方法写入对应的内存,实现原子操作
我们先查看重写Runnable的run方法代码,这个方法作为启动异步线程的方法,可以理解为类的运行入口
public void run() {
if (state != NEW ||
!UNSAFE.compareAndSwapObject(this, runnerOffset,
null, Thread.currentThread()))
return;
try {
Callable<V> c = callable;
if (c != null && state == NEW) {
V result;
boolean ran;
try {
result = c.call();
ran = true;
} catch (Throwable ex) {
result = null;
ran = false;
setException(ex);
}
if (ran)
set(result);
}
} finally {
// runner must be non-null until state is settled to
// prevent concurrent calls to run()
runner = null;
// state must be re-read after nulling runner to prevent
// leaked interrupts
int s = state;
if (s >= INTERRUPTING)
handlePossibleCancellationInterrupt(s);
}
}
- 先判断是否该线程是否启动过了,启动过直接退出,防止重复启动
- 判断成功调用Callable call方法,即调用我们自己重写 Callable的call函数,将结果放入set()
看下set函数代码,我们结合finishCompletion()函数一起看这个结果是如何返回的,
- 先将状态置为完成,后面才会被我们替换成最后状态,防止还未得到最终值就被get()方法调用,起一个哨兵的作用
- finishCompletion()方法会 唤醒get()方法阻塞的线程
protected void set(V v) {
if (UNSAFE.compareAndSwapInt(this, stateOffset, NEW, COMPLETING)) {
outcome = v;
UNSAFE.putOrderedInt(this, stateOffset, NORMAL); // final state
finishCompletion();
}
}
我们看下finishCompletion()方法,
//移除并唤醒所有等待的线程,调用done,并清空callable
private void finishCompletion() {
// assert state > COMPLETING;
for (WaitNode q; (q = waiters) != null;) {
if (UNSAFE.compareAndSwapObject(this, waitersOffset, q, null)) {
//如果能
for (;;) {
Thread t = q.thread;
if (t != null) {
q.thread = null;
LockSupport.unpark(t);//唤醒线程
}
WaitNode next = q.next;
if (next == null)
break;
q.next = null; // unlink to help gc
q = next;
}
break;
}
}
done();
callable = null; // to reduce footprint
}
protected void done() { }//模板方法 可以被其他继承类实现
对于get方法我们只看下不设置超时时间的这个函数,对于get方法我们重点关注awatiDone()
public V get() throws InterruptedException, ExecutionException {
int s = state;
if (s <= COMPLETING)
//用于等待任务执行完成,或者被中断超时
s = awaitDone(false, 0L);
return report(s);//返回outcome结果
}
private int awaitDone(boolean timed, long nanos)
throws InterruptedException {
final long deadline = timed ? System.nanoTime() + nanos : 0L;
WaitNode q = null;
boolean queued = false;
for (;;) {//cas
//1先行判断中断
if (Thread.interrupted()) {
removeWaiter(q);
throw new InterruptedException();
}
int s = state;
//已经完成直接返回
if (s > COMPLETING) {
if (q != null)
q.thread = null;
return s;
}
//state为completeting,将过度到最终出结果状态,直接让出时间片
else if (s == COMPLETING) // cannot time out yet
Thread.yield();
//无节点创建节点,这时本线程则为头结点
else if (q == null)
q = new WaitNode();
//节点未入队列,放入头结点
else if (!queued)
queued = UNSAFE.compareAndSwapObject(this, waitersOffset,
q.next = waiters, q);
else if (timed) {
nanos = deadline - System.nanoTime();
if (nanos <= 0L) {
removeWaiter(q);
return state;
}
LockSupport.parkNanos(this, nanos);
}
else
//阻塞直到被唤醒
LockSupport.park(this);
}
}
看完awaitDone方法我们直到这里就是我们在主函数调用task1.get()方法阻塞主线程的逻辑,而我们之前看的run()方法中的set()方法就是在我们另起的线程中获取到值后修改state值用于唤醒主线程。从这里我们就能够把整个逻辑串起来理解future的代码逻辑。
protected void set(V v) {
if (UNSAFE.compareAndSwapInt(this, stateOffset, NEW, COMPLETING)) {
outcome = v;
UNSAFE.putOrderedInt(this, stateOffset, NORMAL); // final state
finishCompletion();
}
}
然而Future类比较简单,这也导致了如果我们想完成一些复杂的任务可能就比较难,。比如下面一些例子:
将两个异步计算合成一个异步计算,这两个异步计算互相独立,同时第二个又依赖第一个的结果。
当Future集合中某个任务最快结束时,返回结果。
等待Future结合中的所有任务都完成。
通过编程方式完成一个Future任务的执行。
应对Future的完成时间。也就是我们的回调通知。
java8为了更好的实现异步功能,除了completableFuture,我们在后面文章再写一篇介绍completableFuture