FutureTask中Treiber堆的实现

最新推荐文章于 2024-11-19 23:59:14 发布
最新推荐文章于 2024-11-19 23:59:14 发布
阅读量164 收藏
点赞数
CC 4.0 BY-SA版权
原文链接：https://my.oschina.net/7001/blog/875714

2019独角兽企业重金招聘Python工程师标准>>> hot3.png

在文章FutureTask源码分析中简单说明了FutureTask中使用Treiber堆栈来保存等待结果的线程，本文将详细分析其原理。

Treiber堆使用CAS操作来实现节点的入栈和出栈，由于CAS操作只是保证操作的原子性，多线程并发时，其并不能保证可见性，因此必须依赖volatile来保证写入的可见性。这样就可以不必使用加锁来实现对共享数据结构的访问。下面先看一个实现Treiber堆的例子：

public class TreiberStack<E> {
    AtomicReference<Node<E>> head = new AtomicReference<Node<E>>();
    public void push(E item) {//总是在堆顶加入新节点
        Node<E> node= new Node<E>(item);
        Node<E> old;
        do {
            old = head.get();
            node.next = old;
        } while (!head.compareAndSet(old, node));
    }
    public E pop() {//总是从堆顶移除
        Node<E> old;
        Node<E> node;
        do {
            old = head.get();
            if (old == null) 
                return null;
            node = old.next;
        } while (!head.compareAndSet(old,node));
        return old.item;
    }
    private static class Node<E>{
        public final  E  item;
        public Node<E>   next;
        public Node(E item){this.item=item;}
    }

FutureTask中WaitNode 作为节点，并将当前线程保存在其中，而且将栈顶元素保存在waiters中。

入栈

首先看入栈操作，当调用FutureTask的get方法时，若任务未完成则会将当前等待结果的线程加入到等待队列，并挂起当前线程。

    private int awaitDone(boolean timed, long nanos)
        throws InterruptedException {
        final long deadline = timed ? System.nanoTime() + nanos : 0L;
        WaitNode q = null;
        boolean queued = false;
        for (;;) {
            //当前线程是否已中断，该方法会清除线程状态，也就是说第一次调用返回true,
            //并且没有再次被中断时，第二次调用将返回false
            if (Thread.interrupted()) {
                removeWaiter(q);//移除等待者
                throw new InterruptedException();
            }

            int s = state;
            if (s > COMPLETING) {//任务已完成或被取消
                if (q != null)
                    q.thread = null;
                return s;
            }
            else if (s == COMPLETING) //表示任务马上完成，不必进入等待队列
                Thread.yield();
            else if (q == null)//此时s只可能为NEW
                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);//挂起线程
        }
    }

由源码可知，当前线程未被中断时，使用CAS操作加入当前等待节点q，通过将q设为新的栈顶元素，即waiters，同时修改q.next指针指向上一次的waiters。这里使用自旋操作来保证操作一定成功。

看下面例子：

public class FutureTaskStackTest {
    private static FutureTask<Integer> ft=new FutureTask<Integer>(new ComputeTask(0,"task"));
    public static void main(String[] args) throws InterruptedException,ExecutionException{
        ExecutorService   executor=Executors.newSingleThreadExecutor();
        executor.submit(ft);
        executor.shutdown();
        for(int i=0;i<5;i++){
            System.out.println("for loop "+i);
            System.out.println(Thread.currentThread()+":"+ ft.get());
        }
    }
    private static class ComputeTask implements Callable<Integer>{
        private Integer result ;  
        private String  taskName ; 
        public ComputeTask(Integer init, String taskName){  
            result = init;  
            this.taskName = taskName;  
        }  
        @Override
        public Integer call() throws Exception {
            for (int i = 0; i < 100; i++) {  
                result =+ i;  
            } 
            Thread.sleep(5000);
            System.out.println(taskName+" finish!");  
            return result;
        }
        
    }
}

输出：

for loop 0
task finish!
Thread[main,5,main]:99
for loop 1
Thread[main,5,main]:99
for loop 2
Thread[main,5,main]:99
for loop 3
Thread[main,5,main]:99
for loop 4
Thread[main,5,main]:99

ComputeTask将sleep 5000ms才会完成任务，主线程中循环调用5次future.get()。那么等待队列中会加入5个节点吗？实际不是，只会加入一个，当加入一个时，当前main线程会被挂起，即输出“for loop 0”之后被挂起，直到任务完成被唤醒。这就说明同一个线程中调用多次future.get()和调用一次在FutureTask中都将只会加入一个节点，当线程被唤醒时，future.get()将不会被阻塞。

那么使用如下例子：

public class FutureTaskStackTset {
    private static FutureTask<Integer> ft=new FutureTask<Integer>(new ComputeTask(0,"task"));
    public static void main(String[] args) throws InterruptedException,ExecutionException{
        ExecutorService   executor=Executors.newSingleThreadExecutor();
        executor.submit(ft);
        executor.shutdown();
        MyThread thread1=new MyThread();
        thread1.setName("thread1");
        MyThread thread2=new MyThread();
        thread2.setName("thread2");
        thread1.start();
        thread2.start();
        System.out.println(Thread.currentThread().getName()+" : "+ ft.get());
    }
    private static class ComputeTask implements Callable<Integer>{
        private Integer result ;  
        private String  taskName ; 
        public ComputeTask(Integer init, String taskName){  
            result = init;  
            this.taskName = taskName;  
        }  
        @Override
        public Integer call() throws Exception {
            for (int i = 0; i < 100; i++) {  
                result =+ i;  
            } 
            Thread.sleep(5000);
            System.out.println(taskName+" finish!");  
            return result;
        }
        
    }
    private static class MyThread extends Thread{
        public void run() {
            try {
                System.out.println(this.getName()+" : "+ ft.get());
            } catch (InterruptedException | ExecutionException e) {
                e.printStackTrace();
            }
        }
    }
}

输出：

task finish!
main : 99
thread1 : 99
thread2 : 99

在这个例子中，在不同的线程中调用future.get()，因此Treiber堆中会加入3个等待节点。这里main线程中的future.get()必须在启动其他线程之后调用，否则，main线程被阻塞，那么子线程就不会被启动，自然也不会加入等待队列。

移除

awaitDone实现可知，若当前线程被中断，FutureTask将会清理等待队列，移除已经被中断线程的节点。

private void removeWaiter(WaitNode node) {
        if (node != null) {
            node.thread = null;
            retry:
            for (;;) {
                for (WaitNode pred = null, q = waiters, s; q != null; q = s) {
                    s = q.next;
                    if (q.thread != null)
                        pred = q;
                    else if (pred != null) {//移除thread为null的节点
                        pred.next = s;
                        if (pred.thread == null) // check for race
                            continue retry;
                    }//q和pred的thread均为null,将s设为新的栈顶元素，即waiters
                    else if (!UNSAFE.compareAndSwapObject(this, waitersOffset,
                                                          q, s))
                        continue retry;//失败则重新进入循环
                }
                break;
            }
        }
    }

removeWaiter首先将要移除节点的thread变量置为null，这一步很关键，因为后续移除等待节点就是根据thread是否为null来实现。下面分别分析几种可能：

1 waiters即为要移除的元素

181233_28Cq_2663573.png

从代码分析，q指向waiters的节点，s=q->next，则s指向T1，此时q.thread为null，pred也为null，进入else if (!UNSAFE.compareAndSwapObject(this, waitersOffset, q, s))，将s设为waiters，成功移除为null的节点。

2 thread为null元素位于堆栈中间

181842_65vQ_2663573.png

当找到q.thread为null的元素时，pred将指向T1,而S则指向T2，那么程序将会进入else if (pred != null)的代码块，将pred的next指针指向S，则成功将q移除。

完全有可能出现thread为null的元素位于中间甚至末尾的情况，当多线程调用get（）方法时，CAS保证同时只能有一个线程将节点加入等待队列。失败的线程将继续进行自旋操作，直到成功。同时，上文已提过，相同线程多次调用get也只会加入一个节点到等待队列，因此removeWaiter一次调用实际只会移除一个节点。

removeWaiter操作的作用在于移除无效节点，避免造成垃圾累积，当堆栈中节点较多，removeWaiter操作会很慢。通常情况下，不会有太多线程同时等待一个任务的结果。

出栈

当任务执行完成后，将在 finishCompletion()中唤醒所有节点，此时所有线程都可以拿到结果。

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
    }

 finishCompletion()实现即可知，首先使用CAS操作将waiters置为null，然后从栈顶到栈底唤醒所有等待节点，并将节点的thread和next置空，这有助于GC回收内存。

欢迎指出本文有误的地方，转载请注明原文出处https://my.oschina.net/7001/blog/875714

转载于:https://my.oschina.net/7001/blog/875714

使用Treiber算法的非阻塞堆栈实现（Java）
DevScribe的博客
09-06 79
否则，我们将原来的堆栈顶部节点的下一个节点作为新的堆栈顶部节点newTop，并使用CAS操作将newTop设置为新的堆栈顶部。如果CAS操作失败，说明有其他线程同时修改了堆栈的顶部节点，我们需要重新获取最新的顶部节点进行尝试，直到CAS操作成功。在push操作中，我们首先创建一个新的节点newNode，并将原来的堆栈顶部节点作为新节点的下一个节点。如果CAS操作失败，说明有其他线程同时修改了堆栈的顶部节点，我们需要重新获取最新的顶部节点进行尝试，直到CAS操作成功。操作中，我们首先获取当前的堆栈顶部节点。
实现使用 Treiber 算法的非阻塞堆栈 Java
TechChamp的博客
08-14 94
总结来说，通过使用 Treiber 算法实现的非阻塞堆栈，我们可以在并发环境中高效地进行入栈和出栈操作。通过本文提供的源代码，你可以轻松地在 Java 中实现一个非阻塞堆栈。，我们首先创建新节点，并将其 next 指向原来的栈顶元素，然后通过 compareAndSet() 方法更新 top 变量，如果成功说明入栈操作成功。使用 Treiber 算法实现的非阻塞堆栈具有良好的并发性能，可以有效地处理并发访问的问题。上述示例中，我们首先进行了一系列的入栈操作，然后依次进行了出栈操作，并输出了栈顶元素。
Treiber Stack简单分析
weixin_33859844的博客
12-17 171
Abstract Treiber Stack Algorithm是一个可扩展的无锁栈，利用细粒度的并发原语CAS来实现的，Treiber Stack在 R. Kent Treiber在1986年的论文Systems Programming: Coping with Parallelism中首次出现。 基本原理 该算法的基本原理是：只有当您...
Treiber Stack
Light_shine的专栏
10-25 481
Treiber Stack是基于CAS实现的无锁竞争的线程安全stack，jdk8的FutureTask也通过一个简单的Treiber Stack来维护等待线程。以下是具体的Treiber Stack的java实现：public class TreiberStack<E> { AtomicReference<Node<E>> top = new AtomicReference<>();
Treiber Stack介绍
weixin_30800807的博客
10-23 137
简介 Treiber Stack在 R. Kent Treiber在1986年的论文Systems Programming: Coping with Parallelism中首次出现。它是一种无锁并发栈，其无锁的特性是基于CAS原子操作实现的。 实现 下面给出的Java语言实现为《Java并发编程实战》一书的15.4.1小结中的实现。Treiber Stack的实现套路很简单，就是CAS+重试，不...
JUC之 FutureTask 源码与工作原理分析
m0_67698950的博客
04-07 300
JDK1.5 引入了Future模式，Future代表了一个异步任务的执行结果。Future模式可以理解成：主线程将待执行的任务提交给子线程执行后，可以先获取任务结果的持有者Future。然后主线程可以去执行其他的任务。等待到要关注之前任务的执行结果时，再从Future中获取。下面是用户注册的场景。 同步实现时，注册接口响应时间150ms= 用户信息保存50ms + 发送短信50ms + 发送邮件50ms 异步实现时，注册接口响应时间100ms= 用户信息保存50ms + max(发送短信50ms,
CompletableFuture回调机制的设计与实现
最新发布
张彦峰的博客
11-19 5万+
CompletableFuture回调机制的设计与实现：首先分析Future原理总述与局限性，再次分析CompletableFuture原理与回调机制总结，最后从类图分析、整体流程分析和算法实现分析CompletableFuture回调机制设计，结尾给出简单的使用CompletableFuture注意方面
【java】java 多线程 异步计算 FutureTask 源码详解
九师兄
03-19 1141
FutureTask 为 Future 提供了基础实现，如获取任务执行结果(get)和取消任务(cancel)等。如果任务尚未完成，获取任务执行结果时将会阻塞。一旦执行结束，任务就不能被重启或取消(除非使用runAndReset执行计算)。FutureTask 常用来封装 Callable 和 Runnable，也可以作为一个任务提交到线程池中执行。除了作为一个独立的类之外，此类也提供了一些功能性函数供我们创建自定义 task 类使用。FutureTask 的线程安全由CAS来保证。
FutureTask核心源码分析
菼执的博客
08-17 282
看前须知 public interface Executor { void execute(Runnable command); } public interface RunnableFuture<V> extends Runnable, Future<V> { /** * Sets this Future to the result of its computation * unless it has been cancelled.
FutureTask原理解析
KDLin‘s Blog
01-02 1082
引言 我们都知道Runable接口，它非常简单。但是它有一个问题——无法获取执行结果，以及一旦可以获取执行结果，什么时候可以获取执行结果？ public interface Runnable { public abstract void run(); } FutureTask就是为了解决这个问题的，将Runnable包装为FutureTask之后，就可以get获取任务执行结果，如果任务没有执行完，那么当前线程就会阻塞。 FutureTask确实非常好用，但我一直以来都比较好奇，将Runnable包
treiber
03-28
treiber
理解与使用Treiber Stack
靖哥哥的博客
07-02 1186
文章目录背景名称由来CompletableFuture源码实现FutureTask实现Treiber Stack抽象实现入栈出栈示例参考 背景 最近在很多JDK源码中都看到了Treiber stack这个单词。 比如CompletableFuture中的： volatile Completion stack; // Top of Treiber stack of dependent actions 比如FutureTask中的： /** Treiber stack of waiting th
FutureTask详解
落日的博客
08-05 2745
接口功能描述主要方法/特点适用场景Runnable定义要执行的任务，无返回值run()用于执行不需要结果的任务，如线程的任务Callable定义要执行的任务，有返回值，并可能抛出异常call()用于执行有返回值的任务Future管理异步计算的结果，检查状态和处理异常get()cancel()isDone()用于管理异步任务的结果和状态结合Runnable和Future的功能，可以执行任务并管理结果继承Runnable和Future用于需要同时支持Runnable和Future功能的场景，如。
FutureTask源码阅读
了凡的博客
12-01 328
文章目录1.参数说明1.任务状态2.等待的节点：WaiterNode3.返回结果或者返回异常：outcome4.任务回调接口：Callable5.任务线程：runner2.构造函数1.Callable入参2.Runnable入参3.方法实现1.线程执行：run2.获取运行结果：get1.返回执行结果：report2.等待任务执行结束：awaitDown3.移除waiter：removeWaiter...
线程池源码解析之FutureTask
青鸟飞鱼
02-24 286
一、简介 1. 类继承关系 FutureTask类图 2. 状态 private volatile int state; private static final int NEW = 0; private static final int COMPLETING = 1; private static final int NORMAL = 2; pri...
FutureTask源码分析
不争朝夕
11-16 500
Runnable任务类在提交的时候我们并不能检测到运行结果，也不能抛出异常供上层代码捕捉，这个时候就需要有一些标准的阻塞库，能让我们得到结果前阻塞，并且能捕捉异常。FutureTask就是这样一个阻塞库，内部采用的是FILO的非公平链表实现。 测试代码如下： FutureTask&lt;String&gt; task=new FutureTask&lt;String&gt;(new Call...
FutureTask源码解析(2)——深入理解FutureTask
qq_42499188的博客
03-07 590
Future和Task 在深入分析源码之前，我们再来拎一下FutureTask到底是干嘛的。人如其名，FutureTask包含了Future和Task两部分。 FutureTask实现了RunnableFuture接口，即Runnable接口和Future接口。其中Runnable接口对应了FutureTask名字中的Task，代表FutureTask本质上也是表征了一个任务。而Future接...
Java并发编程：深入理解FutureTask
FutureTask是Java并发包`java.util.concurrent`中的一个类，它实现了Runnable接口，这意味着你可以将其提交给ExecutorService执行，同时也实现了Future接口，提供了一种机制来检查任务是否完成、取消任务以及获取或...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值