这个是李大狗在 juc 中提到的算法论文，找了半天网上也没有。
于是决定自己翻译一下。
论文作者：Maged M. Michael Michael L. Scott
翻译作者：老马啸西风
ps: 最近发现自己的文章被各种盗，别人的 SEO 还比自己的高，醉了醉了。
借鉴以前的作者的想法，我们提出了一种新的非阻塞并发队列算法和一种新的双锁队列算法，其中一个队列和一个出队列可以同时进行。
两种算法都很简单，快速且实用。我们很惊讶没有在文献中找到它们。
在12节点SGI Challenge多处理器上进行的实验表明，新的非阻塞队列始终胜过最著名的替代方案。对于提供通用原子原语的机器（例如比较和交换或加载链接/存储条件的），这是显而易见的选择算法。
有时我们须要对元素进行配对和交换线程的同步点，使用 exchange 方法返回其伙伴的对象，这时我们就须要使用线程类中的 Exchanger 类了，
简而言之，可以在不同线程间交换数据。
废话少说，直接上代码。
private static class ExchangeRunnable implements Runnable {
private final Exchanger exchanger;
private final String data;
private ExchangeRunnable(Exchanger exchanger, String data) {
this.exchanger = exchanger;
this.data = data;
}
@Override
public void run() {
try {
System.out.println(Thread.currentThread().getName() +" 正在把数据 "+ data + " 交换出去" );
Thread.sleep((long) (Math.random()*1000));
String data2 = exchanger.exchange(data);
System.out.println(Thread.currentThread().getName() + " 交换数据到 "+ data2);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}可重用的同步屏障，其功能类似于CyclicBarrier和CountDownLatch，但支持更灵活的用法。
这个工具类我们暂时就翻译为：移相器/相位器
我们来看一个简单的例子。
假设我们有一个比赛，有多位玩家参加。
当所有玩家完成第一次比赛，我们认为上半场游戏结束；全部参加完第二次比赛，认为下半场游戏结束。
这个要如何实现呢？
public class MyPhaser extends Phaser {
@Override
protected boolean onAdvance(int phase, int registeredParties) {
switch (phase) {
case 0 :
System.out.println("上半场完成");
return false;
case 1:
System.out.println("下半场完成");
return false;
default:
return true;
}
}
}缓存系统中是以缓存行（cache line）为单位存储的。
缓存行是2的整数幂个连续字节，一般为32-256个字节。最常见的缓存行大小是64个字节。
当多线程修改互相独立的变量时，如果这些变量共享同一个缓存行，就会无意中影响彼此的性能，这就是伪共享。
缓存行上的写竞争是运行在SMP系统中并行线程实现可伸缩性最重要的限制因素。
有人将伪共享描述成无声的性能杀手，因为从代码中很难看清楚是否会出现伪共享。
为了让可伸缩性与线程数呈线性关系，就必须确保不会有两个线程往同一个变量或缓存行中写。
java.util.concurrent 是 java 为并发提供的强大的工具包。
本文将整理学习常见的类，API，适用场景，源码。
重点是类本身，并发和 jmm 将在其他系列学习。
Array是Java特有的数组。在你知道所要处理数据元素个数的情况下非常好用。java.util.Arrays 包含了许多处理数据的实用方法：
Arrays.asList：可以从 Array 转换成 List。可以作为其他集合类型构造器的参数。
Arrays.binarySearch：在一个已排序的或者其中一段中快速查找。
Arrays.copyOf：如果你想扩大数组容量又不想改变它的内容的时候可以使用这个方法。
Arrays.copyOfRange：可以复制整个数组或其中的一部分。
Arrays.deepEquals、Arrays.deepHashCode：Arrays.equals/hashCode的高级版本，支持子数组的操作。
Arrays.equals：如果你想要比较两个数组是否相等，应该调用这个方法而不是数组对象中的 equals方法（数组对象中没有重写equals()方法，所以这个方法之比较引用而不比较内容）。这个方法集合了Java 5的自动装箱和无参变量的特性，来实现将一个变量快速地传给 equals() 方法——所以这个方法在比较了对象的类型之后是直接传值进去比较的。
Arrays.fill：用一个给定的值填充整个数组或其中的一部分。
Arrays.hashCode：用来根据数组的内容计算其哈希值（数组对象的hashCode()不可用）。这个方法集合了Java 5的自动装箱和无参变量的特性，来实现将一个变量快速地传给 Arrays.hashcode方法——只是传值进去，不是对象。
Arrays.sort：对整个数组或者数组的一部分进行排序。也可以使用此方法用给定的比较器对对象数组进行排序。
Arrays.toString：打印数组的内容。
原子是世界上的最小单位，具有不可分割性。
比如 a=0；（a非long和double类型） 这个操作是不可分割的，那么我们说这个操作时原子操作。
再比如：a++； 这个操作实际是a = a + 1；是可分割的，所以他不是一个原子操作。非原子操作都会存在线程安全问题，需要我们使用同步技术（sychronized）来让它变成一个原子操作。一个操作是原子操作，那么我们称它具有原子性。
java的concurrent包下提供了一些原子类，我们可以通过阅读API来了解这些原子类的用法。
比如：AtomicInteger、AtomicLong、AtomicReference等。
可以原子性更新的引用值。
AtomicReference 和 AtomicInteger 比较类似。
都有 Unsafe 属性，和一个对应的值偏移量。
区别就是此处的 value 是通过 volatile 关键字修饰的变量。
public class AtomicReference implements java.io.Serializable {
private static final long serialVersionUID = -1848883965231344442L;
private static final Unsafe unsafe = Unsafe.getUnsafe();
private static final long valueOffset;
static {
try {
valueOffset = unsafe.objectFieldOffset
(AtomicReference.class.getDeclaredField("value"));
} catch (Exception ex) { throw new Error(ex); }
}
private volatile V value;
/**
* Creates a new AtomicReference with the given initial value.
*
* @param initialValue the initial value
*/
public AtomicReference(V initialValue) {
value = initialValue;
}
/**
* Creates a new AtomicReference with null initial value.
*/
public AtomicReference() {
}
}可以原子性更新的 Integer 值，当然这个类并不能完全替代 Integer 对象。
使用起来还是很方便的。
比如说我们定义一个计数器，使用 AtomicInteger 可以同时兼顾性能与并发安全。
可以原子更新的 Long 值。
AtomicLong用于诸如原子递增的序列号之类的应用程序中，并且不能用作Long的替代品。
但是，此类确实扩展了Number，以允许通过处理基于数字的类的工具和实用程序进行统一访问。
LongAdder中会维护一个或多个变量，这些变量共同组成一个long型的“和”。当多个线程同时更新（特指“add”）值时，为了减少竞争，可能会动态地增加这组变量的数量。“sum”方法（等效于longValue方法）返回这组变量的“和”值。
当我们的场景是为了统计技术，而不是为了更细粒度的同步控制时，并且是在多线程更新的场景时，LongAdder类比AtomicLon g更好用。 在小并发的环境下，论更新的效率，两者都差不多。但是高并发的场景下，LongAdder有着明显更高的吞吐量，但是有着更高的空间复杂度。