在javaeye有位朋友问了我一个非常好的问题。

问题

一个线程向volatile的数组中设置值，而另一个线程向volatile的数组中读取。
比如seg.setValue(2)，随后另一个线程调用seg.getValue(2)，前一个线程设置的值对读取的线程是可见的吗？

我看书上说volatile的数组只针对数组的引用具有volatile的语义，而不是它的元素。

ConcurrentHashMap中也有这样的代码，我很疑惑，希望得到你的解答，谢谢。

阅读全文

原文地址：http://mechanitis.blogspot.com/2011/06/dissecting-disruptor-how-do-i-read-from.html（因为有墙转载到墙内）

作者：Trisha

The next in the series of understanding the Disruptor pattern developed at LMAX.

After the last post we all understand ring buffers and how awesome they are.  Unfortunately for you, I have not said anything about how to actually populate them or read from them when you’re using the Disruptor.

ConsumerBarriers and Consumers
I’m going to approach this slightly backwards, because it’s probably easier to understand in the long run.  Assuming that some magic has populated it: how do you read something from the ring buffer?

(OK, I’m starting to regret using Paint/Gimp.  Although it’s an excellent excuse to purchase a graphics tablet if I do continue down this road.  Also UML gurus are probably cursing my name right now.)

阅读全文

原文地址：http://mechanitis.blogspot.com/2011/07/dissecting-disruptor-writing-to-ring.html（因被墙移到墙内）  作者：Trisha

This is the missing piece in the end-to-end view of the Disruptor.  Brace yourselves, it’s quite long.  But I decided to keep it in a single blog so you could have the context in one place.

The important areas are: not wrapping the ring; informing the consumers; batching for producers; and how multiple producers work. 阅读全文

原文：http://gee.cs.oswego.edu/dl/jmm/cookbook.html

作者：Doug Lea 翻译：丁一

1. 前言
2. 指令重排
3. 内存屏障
4. 多处理器
5. 指南

单处理器(Uniprocessors)

如果能保证正在生成的代码只会运行在单个处理器上，那就可以跳过本节的其余部分。因为单处理器保持着明显的顺序一致性，除非对象内存以某种方式与可异步访问的IO内存共享，否则永远都不需要插入屏障指令。采用了特殊映射的java.nio buffers可能会出现这种情况，但也许只会影响内部的JVM支持代码，而不会影响Java代码。而且，可以想象，如果上下文切换时不要求充分的同步，那就需要使用一些特殊的屏障了。

阅读全文

原文地址：http://mechanitis.blogspot.com/2011/08/disruptor-20-all-change-please.html  （因被墙移到墙内）  作者：Trisha

Martin recently announced version 2.0 of the Disruptor – basically there have been so many changes since we first open-sourced it that it’s time to mark that officially.  His post goes over all the changes, the aim of this article is to attempt to translate my previous blog posts into new-world-speak, since it’s going to take a long time to re-write each of them all over again. Now I see the disadvantage of hand-drawing everything.

阅读全文

原文地址：http://mechanitis.blogspot.com/2011/06/dissecting-disruptor-whats-so-special.html（因被墙移到墙内） 作者：Trisha

Recently we open sourced the LMAX Disruptor, the key to what makes our exchange so fast.  Why did we open source it?  Well, we’ve realised that conventional wisdom around high performance programming is… a bit wrong. We’ve come up with a better, faster way to share data between threads, and it would be selfish not to share it with the world.  Plus it makes us look dead clever.

On the site you can download a technical article explaining what the Disruptor is and why it’s so clever and fast.  I even get a writing credit on it, which is gratifying when all I really did is insert commas and re-phrase sentences I didn’t understand.

However I find the whole thing a bit much to digest all at once, so I’m going to explain it in smaller pieces, as suits my NADD audience.

First up – the ring buffer.  Initially I was under the impression the Disruptor was just the ring buffer.  But I’ve come to realise that while this data structure is at the heart of the pattern, the clever bit about the Disruptor is controlling access to it.
阅读全文

原文：http://ifeve.com/disruptor-locks-are-bad/

作者：Trisha’s  译者：张文灼，潘曦  整理和校对：方腾飞，丁一

Martin Fowler写了一篇非常好的文章，里面不仅提到了Disruptor,而且还解释了Disruptor 如何应用在LMAX的架构里。里面有提及了一些目前没有涉及的概念，但最经常问到的问题是 “Disruptor究竟是什么?＂。

目前我正准备在回答这个问题，但首先回答＂为什么它会这么快?＂

这些问题持续出现，但是我不能没有说它是干什么的就说它为什么会这么快，不能没有说它为什么这样做就说它是什么东西。

所以我陷入了一个僵局，一个如何写博客的僵局。

要打破这个僵局，我准备以最简单方式回答第一个问题，如果幸运的话，在以后博文里，如果需要解释的话我会重新提回：Disruptor提供了一种线程之间信息交换的方式。

作为一个开发者,因为＂线程＂一词的出现，我的警钟已经敲响，它意味着并发，而并发是困难的。

阅读全文

原文：http://gee.cs.oswego.edu/dl/jmm/cookbook.html 第二节

作者：Doug Lea 翻译：潘曦   校对：方腾飞

1. 指令重排
2. 内存屏障
3. 多处理器
4. 指南

编译器和处理器必须同时遵守重排规则。由于单核处理器能确保与“顺序执行”相同的一致性，所以在单核处理器上并不需要专门做什么处理，就可以保证正确的执行顺序。但在多核处理器上通常需要使用内存屏障指令来确保这种一致性。即使编译器优化掉了一个字段访问（例如，因为一个读入的值未被使用），这种情况下还是需要产生内存屏障，就好像这个访问仍然需要保护。（可以参考下面的优化掉内存屏障的章节）。

内存屏障仅仅与内存模型中“获取”、“释放”这些高层次概念有间接的关系。内存屏障并不是“同步屏障”，内存屏障也与在一些垃圾回收机制中“写屏障（write barriers）”的概念无关。内存屏障指令仅仅直接控制CPU与其缓存之间，CPU与其准备将数据写入主存或者写入等待读取、预测指令执行的缓冲中的写缓冲之间的相互操作。这些操作可能导致缓冲、主内存和其他处理器做进一步的交互。但在JAVA内存模型规范中，没有强制处理器之间的交互方式，只要数据最终变为全局可用，就是说在所有处理器中可见，并当这些数据可见时可以获取它们。
阅读全文

原文地址：http://martinfowler.com/articles/lmax.html 作者：Martin Fowler

译文地址：http://www.jdon.com/42452 译者：banq

LMAX是一种新型零售金融交易平台，它能够以很低的延迟(latency)产生大量交易(吞吐量). 这个系统是建立在JVM平台上，核心是一个业务逻辑处理器，它能够在一个线程里每秒处理6百万订单. 业务逻辑处理器完全是运行在内存中(in-memory)，使用事件源驱动方式(event sourcing). 业务逻辑处理器的核心是Disruptors，这是一个并发组件，能够在无锁的情况下实现网络的Queue并发操作。他们的研究表明，现在的所谓高性能研究方向似乎和现代CPU设计是相左的。

目录

1. 整体架构
2. 业务逻辑处理
3. Disruptors的输入和输出
4. 队列和机制偏爱的缺乏
5. 你需要使用这个架构吗

过去几年我们不断提供这样声音：免费午餐已经结束。我们不再能期望在单个CPU上获得更快的性能，因此我们需要写使用多核处理的并发软件，不幸的是， 编写并发软件是很难的，锁和信号量是很难理解的和难以测试，这意味着我们要花更多时间在计算机上，而不是我们的领域问题，各种并发模型，如Actors 和软事务STM(Software Transactional Memory), 目的是更加容易使用，但是按下葫芦飘起瓢，还是带来了bugs和复杂性.

我很惊讶听到去年3月QCon上一个演讲， LMAX是一种新的零售的金融交易平台。它的业务创新 – 允许任何人在一系列的金融衍生产品交易。这就需要非常低的延迟，非常快速的处理，因为市场变化很快，这个零售平台因为有很多人同时操作自然具备了复杂性，用户越多，交易量越大，不断快速增长。

鉴于多核心思想的转变，这种苛刻的性能自然会提出一个明确的并行编程模型 ，但是他们却提出用一个线程处理6百万订单，而且是每秒，在通用的硬件上。

通过低延迟处理大量交易，取得低延迟和高吞吐量，而且没有并发代码的复杂性，他们是怎么做到呢？现在LMAX已经产品化一段时间了，现在应该可以揭开其神秘而迷人的面纱了。

阅读全文

原文：http://gee.cs.oswego.edu/dl/jmm/cookbook.html

作者：Doug Lea 翻译：古圣昌   校对：欧振聪，方腾飞

1. 指令重排
2. 内存屏障
3. 多处理器
4. 指南

本文总结了在多处理器(MPs)中常用的的处理器列表，处理器相关的信息都可以从链接指向的文档中得到（一些网站需要通过注册才能得到相应的手册）。当然，这不是一个完全详细的列表，但已经包括了我所知道的在当前或者将来Java实现中所使用的多核处理器。下面所述的关于处理器的列表和内容也不一定权威。我只是总结一下我所阅读过的文档，但是这些文档也有可能是被我误解了，一些参考手册也没有把Java内存模型(JMM)相关的内容阐述清楚，所以请协助我把本文变得更准确。
阅读全文

原文：http://gee.cs.oswego.edu/dl/cpj/jmm.html 第三章
作者：Doug Lea 译者：程晓明 校对：方腾飞

只有在下列情况时，一个线程对字段的修改才能确保对另一个线程可见：

一个写线程释放一个锁之后，另一个读线程随后获取了同一个锁。本质上，线程释放锁时会将强制刷新工作内存中的脏数据到主内存中，获取一个锁将强制线程装载（或重新装载）字段的值。锁提供对一个同步方法或块的互斥性执行，线程执行获取锁和释放锁时，所有对字段的访问的内存效果都是已定义的。

注意同步的双重含义：锁提供高级同步协议，同时在线程执行同步方法或块时，内存系统（有时通过内存屏障指令）保证值的一致性。这说明，与顺序程序设计相比较，并发程序设计与分布式程序设计更加类似。同步的第二个特性可以视为一种机制：一个线程在运行已同步方法时，它将发送和/或接收其他线程在同步方法中对变量所做的修改。从这一点来说，使用锁和发送消息仅仅是语法不同而已。

阅读全文

原文地址：http://mechanitis.blogspot.com/2011/08/dissecting-disruptor-why-its-so-fast.html （因有墙，移到墙内）

My recent slow-down in posting is because I’ve been trying to write a post explaining memory barriersand their applicability in the Disruptor. The problem is, no matter how much I read and no matter how many times I ask the ever-patient Martin and Mike questions trying to clarify some point, I just don’t intuitively grasp the subject. I guess I don’t have the deep background knowledge required to fully understand.

So, rather than make an idiot of myself trying to explain something I don’t really get, I’m going to try and cover, at an abstract / massive-simplification level, what I do understand in the area.  Martin has written a post going into memory barriers in some detail, so hopefully I can get away with skimming the subject.

阅读全文

原文地址：http://mechanitis.blogspot.com/2011/07/dissecting-disruptor-why-its-so-fast_22.html（因有墙移到墙内）

We mention the phrase Mechanical Sympathy quite a lot, in fact it’s even Martin’s blog title.  It’s about understanding how the underlying hardware operates and programming in a way that works with that, not against it.

We get a number of comments and questions about the mysterious cache line padding in theRingBuffer, and I referred to it in the last post.  Since this lends itself to pretty pictures, it’s the next thing I thought I would tackle.
阅读全文

原文地址：http://mechanitis.blogspot.com/2011/07/dissecting-disruptor-why-its-so-fast.html（因前方有墙，所以我移到墙内）

Martin Fowler has written a really good article describing not only the Disruptor, but also how it fits into the architecture at LMAX.  This gives some of the context that has been missing so far, but the most frequently asked question is still “What is the Disruptor?”.

I’m working up to answering that.  I’m currently on question number two: “Why is it so fast?”.

These questions do go hand in hand, however, because I can’t talk about why it’s fast without saying what it does, and I can’t talk about what it is without saying why it is that way.

So I’m trapped in a circular dependency.  A circular dependency of blogging.

To break the dependency, I’m going to answer question one with the simplest answer, and with any luck I’ll come back to it in a later post if it still needs explanation: the Disruptor is a way to pass information between threads.
阅读全文

Doug Lea 的文献

1. Synchronizer Framework  译者：ClarenceAu （已翻译完成,在校对）
2. Fork/Join  译者：Alex（陆续发表中）
3. Java Concurrency Constructs 译者：萧欢（已翻译完成）
4. Cancellation 译者：丁一  （已翻译完成）

以下文章来自：https://code.google.com/p/disruptor/wiki/BlogsAndArticles

如何使用Disruptor

1. What’s so special about a ring buffer? – A summary by Trisha of the data structure at the heart of the Disruptor patter, how it’s implemented and what’s so great about it. （译者：淘宝-欧立勇）
2. How do I read from a ring buffer? – Trisha gives an overview of the Consumer and ConsumerBarrier, which allows you to read stuff off the ring buffer.(译者：古圣昌)
3. Writing to the ring buffer – The third piece from Trisha explaining how to write to the ring buffer, and how it avoids wrapping.（译者：长源）
4. Lock-free publishing – Danny outlines the concepts behind putting items into the ring buffer.（译者：行知）
5. DSL for wiring up the Disruptor – Adrian came up with a cunning way to configure your Disruptor(译者：杨帆)
6. Disruptor wizard now part of the Disruptor – Adrian’s wizard now makes it easy to configure your very own Disruptor straight out of the box (译者：杨帆)
7. Disruptor version 2.0 – Trisha outlines the cosmetic changes to the Disruptor in version 2.0.(译者：杨帆)
8. Sharing Data Among Threads Without Contention – An updated and summarised version of Trisha’s blogs in Oracle’s Java Magazine.（译者：同杰）

Disruptor为什么这么快

1. Locks Are Bad – Trisha gives some basic concurrency background and explains why locks are evil. (译者：nick，潘曦，已经翻译完成)
2. Magic cache line padding – An explanation around why the odd cache line padding variables are required, by Trisha.(译者：方腾飞，已经翻译完)
3. Demystifying Memory Barriers – Trisha attempts to explain why memory barriers are important in the Disruptor. （译者：杜建雄）

其他人写的Disruptor文章

1. LMAX 架构  by Martin Fowler (已翻译)
2. Processing 1m TPS with the Axon Framework using the Disruptor.（译者，程晓明）

有兴趣的同学可以一起参与，有什么其他并发文献希望我们翻译的也可以通过留言告知我们。

如何翻译

1. 你可从以上几篇文章中挑选某一篇进行翻译，翻译时间最好是一个星期以内，翻译前请发邮件到main_shorttime（AT）163.com告诉我你要翻译的文章和预计完成时间。
2. 译者署名的顺序由翻译的字数确定。
3. 与其他译者交叉校对，互相讨论翻译与技术问题。
4. 提交翻译：在并发编程网用QQ登陆，然后发布译文。

注意事项