理解与使用Treiber Stack
背景
最近在很多JDK源码中都看到了Treiber stack
这个单词。
- 比如CompletableFuture中的:
volatile Completion stack; // Top of Treiber stack of dependent actions
- 比如FutureTask中的:
/** Treiber stack of waiting threads */
private volatile WaitNode waiters;
- 比如Phaser中的:
/**
* Wait nodes for Treiber stack representing wait queue
*/
static final class QNode implements ForkJoinPool.ManagedBlocker {
final Phaser phaser;
final int phase;
final boolean interruptible;
final boolean timed;
boolean wasInterrupted;
long nanos;
final long deadline;
volatile Thread thread; // nulled to cancel wait
QNode next;
- 还比如ForkJoinPool中的描述:
* Bits and masks for field ctl, packed with 4 16 bit subfields:
* AC: Number of active running workers minus target parallelism
* TC: Number of total workers minus target parallelism
* SS: version count and status of top waiting thread
* ID: poolIndex of top of Treiber stack of waiters
感觉这种名词出现的频率有点高,需要深入了解一下。
名称由来
Treiber Stack在 R. Kent Treiber在1986年的论文Systems Programming: Coping with Parallelism中首次出现。它是一种无锁并发栈,其无锁的特性是基于CAS原子操作实现的。
CompletableFuture源码实现
CompletableFuture的Treiber stack实现感觉有点复杂,因为有其他逻辑掺杂,代码不容易阅读,其实抽象来看,Treiber stack首先是个单向链表,链表头部即栈顶元素,在入栈和出现过程中,需要对栈顶元素进行CAS控制,防止多线程情况下数据错乱。
// Either the result or boxed AltResult
volatile Object result;
// Top of Treiber stack of dependent actions(Treiber stack栈顶元素)
volatile Completion stack;
/** Returns true if successfully pushed c onto stack. */
final boolean tryPushStack(Completion c) {
Completion h = stack;
lazySetNext(c, h);
return UNSAFE.compareAndSwapObject(this, STACK, h, c);
}
/** Unconditionally pushes c onto stack, retrying if necessary. */
final void pushStack(Completion c) {
do {} while (!tryPushStack(c));
}
简单来看,入栈的步骤如下:
- 尝试入栈,利用CAS将新的节点作为栈顶元素,新节点next赋值为旧栈顶元素
- 尝试入栈成功,即结束;入栈失败,继续重试上面的操作
FutureTask实现
FutureTask用了Treiber Stack来维护等待任务完成的线程,在FutureTask的任务完成/取消/异常后在finishCompletion钩子方法中会唤醒栈中等待的线程。
Treiber Stack抽象实现
入栈
void push(Node new) {
do {
} while(!tryPush(new)) // 尝试入栈
}
boolean tryPush(node) {
Node oldHead = head;
node.next = oldHead; // 新节点next赋值为旧栈顶元素
return CAS(oldHead, node); // 利用CAS将新的节点作为栈顶元素
}
出栈
对于出栈,要做的工作就是将原来的栈顶节点移除,等待垃圾回收;新栈顶元素CAS为第一个子元素。伪代码:
E pop() {
Node<E> oldHead;
Node<E> newHead;
do {
oldHead = top.get();
// 判断栈是否为空,为空直接返回
if (oldHead == null)
return null;
newHead = oldHead.next;
} while (!CAS(oldHead, newHead));
// 旧的节点删掉next引用,等待gc
oldHead.item = null;
return oldHead.item;
}
示例
import sun.misc.Unsafe;
import java.lang.reflect.Field;
import java.util.Objects;
import java.util.Optional;
import java.util.Random;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
/**
* 基于Unsafe实现TreiberStack
* @author Charles
*/
public class TreiberStack<E> {
private volatile Node<E> head;
public void push(E item) {
Objects.requireNonNull(item);
Node<E> newHead = new Node<>(item);
Node<E> oldHead;
int count = 0;
do {
oldHead = head;
count++;
} while (!tryPush(oldHead, newHead, count));
newHead.next = oldHead;
}
private boolean tryPush(Node<E> oldHead, Node<E> newHead, int count) {
boolean isSuccess = UNSAFE.compareAndSwapObject(this, HEAD, oldHead, newHead);
System.out.println(currentThreadName() + " try push [" + count + "]," +
" oldHead = " + getValue(oldHead) +
" newHead = " + getValue(newHead) +
" isSuccess = " + isSuccess);
return isSuccess;
}
public E pop() {
Node<E> oldHead;
Node<E> newHead;
do {
oldHead = head;
System.out.println(currentThreadName() + " do pop:" +
" oldHead = " + getValue(oldHead) +
" newHead = " + Optional.ofNullable(head).map(s -> s.next.item).orElse(null));
if (oldHead == null) {
return null;
}
newHead = oldHead.next;
} while (!tryPop(oldHead, newHead));
oldHead.next = null;
return oldHead.item;
}
private boolean tryPop(Node<E> oldHead, Node<E> newHead) {
boolean isSuccess = UNSAFE.compareAndSwapObject(this, HEAD, oldHead, newHead);
System.out.println(currentThreadName() + " try pop:" +
" oldHead = " + getValue(oldHead) +
" currentHead = " + getValue(head) +
" newHead = " + getValue(newHead) +
" isSuccess: " + isSuccess);
return isSuccess;
}
private E getValue(Node<E> n) {
return Optional.ofNullable(n).map(t -> t.item).orElse(null);
}
private static class Node<E> {
E item;
Node<E> next;
Node(E item) {
this.item = item;
}
}
// Unsafe mechanics
private static final sun.misc.Unsafe UNSAFE;
private static final long HEAD;
private static final long NEXT;
static {
try {
Field getUnsafe = sun.misc.Unsafe.class.getDeclaredField("theUnsafe");
getUnsafe.setAccessible(true);
UNSAFE = (Unsafe) getUnsafe.get(null);
Class<?> k = TreiberStack.class;
HEAD = UNSAFE.objectFieldOffset(k.getDeclaredField("head"));
NEXT = UNSAFE.objectFieldOffset(TreiberStack.Node.class.getDeclaredField("next"));
} catch (Exception x) {
throw new Error(x);
}
}
private static class RandomValue {
private final Integer value;
public RandomValue() {
this.value = new Random().nextInt(Integer.MAX_VALUE);
}
public Integer getValue() {
return value;
}
@Override
public String toString() {
return value.toString();
}
}
private static String currentThreadName() {
return System.nanoTime() + " / " + Thread.currentThread().getName();
}
public static void main(String[] args) throws InterruptedException {
TreiberStack<RandomValue> ts = new TreiberStack<>();
ExecutorService es = Executors.newFixedThreadPool(10);
Thread.sleep(2000);
for (int i = 0; i < 5; i++) {
es.submit(() -> ts.push(new RandomValue()));
}
for (int i = 0; i < 50; i++) {
es.submit((Runnable) ts::pop);
}
}
}
参考
Wiki Treiber Stack
Treiber Stack介绍
Treiber stack设计
理解与使用Treiber Stack的更多相关文章
- Treiber Stack介绍
简介 Treiber Stack在 R. Kent Treiber在1986年的论文Systems Programming: Coping with Parallelism中首次出现.它是一种无锁并发 ...
- 理解Django 中Call Stack 机制的小Demo
1.工作流程 request/response模式下,request并不是直接到达view方法,view方法也不是将返回的response直接发送给浏览器的,而是request由外到里的层层通过各种m ...
- 彻底理解JDK异步
学而时习之,不亦说乎! --<论语> 首发,转载请附原文链接,谢谢. 原文使用MD格式编写,复制进来代码缩成一团了,读者见谅,需要 ...
- 【python】Numpy中stack(),hstack(),vstack()函数详解
转自 https://blog.csdn.net/csdn15698845876/article/details/73380803 这三个函数有些相似性,都是堆叠数组,里面最难理解的应该就是stack ...
- 从CompletableFuture到异步编程设计
从CompletableFuture到异步编程设计,笔者就分为2部分来分享CompletableFuture异步编程设计,前半部分总结下CompletableFuture使用实践,后半部分分享下Com ...
- JDK线程池的使用
转载自:https://my.oschina.net/hosee/blog/614319: 摘要: 本系列基于炼数成金课程,为了更好的学习,做了系列的记录. 本文主要介绍: 1. 线程池的基本使用 2 ...
- Future接口和Callable接口以及FeatureTask详解
类继承关系 Callable接口 @FunctionalInterface public interface Callable<V> { V call() throws Exception ...
- 并发编程(四)TaskFuture
并发编程(四)TaskFuture ExecutorService executorService = Executors.newSingleThreadExecutor(); Future<O ...
- Java并发编程--ThreadPoolExecutor
概述 为什么要使用线程池? 合理利用线程池能够带来三个好处.第一:降低资源消耗.通过重复利用已创建的线程降低线程创建和销毁造成的消耗.第二:提高响应速度.当任务到达时,任务可以不需要等到线程创建就能立 ...
随机推荐
- c++ stl库中的set
简单说来 set(集合)里的元素 不会有相同元素(也就是说 相同的值不存 )并且 存进去会自动排序 类比sort默认排序从小到大 set排序也是 set/multiset会根据待定的排序准则,自动将 ...
- MacOs/Liunx主机搭建windows平台双机调试环境
0x00 前言 本文的主要试用对象是Mac OS/Linux用户,对于想调试windows内核相关的一些东西时,需要搭建双机调试环境的一些记录.另外对于本机是windows的用户也完全试用,windo ...
- 《JavaScript高级程序设计》——第四章 变量、作用域和内存管理
JavaScript变量可以用保存两种类型的值:基本类型值和引用类型值.基本类型的值源自以下基本类型数据:Undefined.Null.Boolean.Number和String. 从一个变量向另一个 ...
- D. Tavas and Malekas 解析(字串匹配)
Codeforce 535 D. Tavas and Malekas 解析(字串匹配) 今天我們來看看CF535D 題目連結 題目 給你一個字串$p$和一些$index$代表字串$p$在哪些位置會和長 ...
- F2. Same Sum Blocks (Hard) 解析(思維、前綴和、貪心)
Codeforce 1141 F2. Same Sum Blocks (Hard) 解析(思維.前綴和.貪心) 今天我們來看看CF1141F2(Hard) 題目連結 題目 給你一個數列\(a\),要你 ...
- TCP连接性能指标之TCP关闭过程(四次挥手)
TCP关闭过程(四次挥手): ESTABLISHED: 当前建立连接状态 CLOSE_WAIT:Server端收到来自Client端的FIN包后,发送ACK回Client端,进入CLOSE_WAIT ...
- Centos7中MySQL8.0安装过程及遇到的问题记录
本文主要参考以下2篇文章,安装操作 https://www.miboxapp.com/article/detail/1146659339214393344 https://blog.csdn.net/ ...
- [Luogu P3157][CQOI2011]动态逆序对 (树套树)
题面 传送门:[CQOI2011]动态逆序对 Solution 一开始我看到pty巨神写这套题的时候,第一眼还以为是个SB题:这不直接开倒车线段树统计就完成了吗? 然后冷静思考了一分钟,猛然发现单纯的 ...
- .NetCore简单封装基于IHttpClientFactory的HttpClient请求
IHttpClientFactory是什么?为什么出现了IHttpClientFactory 一.IHttpClientFactory是什么? IHttpClientFactory是.netcore2 ...
- ABP框架中一对多,多对多关系的处理以及功能界面的处理(1)
在我们开发业务的时候,一般数据库表都有相关的关系,除了单独表外,一般还包括一对多.多对多等常见的关系,在实际开发过程中,需要结合系统框架做对应的处理,本篇随笔介绍基于ABP框架对EF实体.DTO关系的 ...