你好，作为一名刚入行的程序员来说，看你这篇文章其实挺吃力的，特别是重排序那块，整个文章读下来的感觉，线程之间的通信和svn的使用相差不多，但是不知道，在2个线程之间发生 所谓的“冲突” 该如何处理，就像你描述在例子中 x=y=0的 ，你还是没有将如何操作才能得到我们所想要的结果呢，根据happens-before 这样的原则么，这个是不是和svn解决冲突是相类似的呢？

您好，看了您很多并发方面的文章感觉受益很多。

在原来看并发时一直有一个疑问就是happens-before是谁来保证的呢？是我们在开发过程中需要注意的地方？还是JVM中的一些策略呢？也可以说是：是不是在开发中不需要关注happens-before原则呢？
因为比如：程序顺序规则：一个线程中的每个操作，happens- before 于该线程中的任意后续操作。这种规则是我们在写代码的过程中是无法保证的，只能是JVM来保证。
请问happens-before到底是JVM中的一种策略还是我们在编写代码中需要注意的地方？

你好，看完之后豁然开朗。不过还是有两个疑问：
1.两个操作之间具有happens-before关系，并不意味着前一个操作必须要在后一个操作之前执行！
这句话是什么意思，感觉跟happen-before有冲突的样子，不是很理解。
2.一个线程在写volatile变量之前可见的所有共享变量，在接下来另一个线程读同一个volatile变量后，将立即变得对这个线程可见。
这个是volatile必然有的保障吗，JMM可以确保这个保障吗，还是一般实现支持它，但是JMM标准对它却没有定义？

您好，请问一下，关于重排序的那个例子，我写了代码验证，在反复执行100w次的情况下，都没有出现x=y=0的结果，难道是因为很难出现这种情况吗？我的代码如下：
public class TestReordering {

private int a = 0;
private int b = 0;

private class ThreadATask implements Runnable {
private int x;

public void run() {
a = 1; // A1
x = b; // A2
}

public int getX() {
return x;
}
}

private class ThreadBTask implements Runnable {
private int y;

public void run() {
b = 2; // B1
y = a; // B2
}

public int getY() {
return y;
}
}

public String doTest() throws InterruptedException {
ThreadATask taskA = new ThreadATask();
ThreadBTask taskB = new ThreadBTask();
Thread threadA = new Thread(taskA);
Thread threadB = new Thread(taskB);

threadA.start();
threadB.start();

threadA.join();
threadB.join();

return “x=” + taskA.getX() + “, y=” + taskB.getY();
}

/**
* @param args
* @throws InterruptedException
*/
public static void main(String[] args) throws InterruptedException {
Map counter = new HashMap();

for (int i = 0; i < Integer.parseInt(args[0]); i++) {
TestReordering test = new TestReordering();
String result = test.doTest();

Integer count = counter.get(result);
if (count == null) {
count = 0;
}
counter.put(result, count.intValue() + 1);
}

for (String result : counter.keySet()) {
System.out.println(result + ", count=" + counter.get(result));
}
}

}

恩，确实如此，多谢耐心解答！

文章中说的抽象的线程本地内存和线程存放局部变量的栈不是同一个吧？

偶丰富了一下上边提到的例子：
package test034;

import java.util.concurrent.BrokenBarrierException;
import java.util.concurrent.Callable;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;

public class ReorderTest {
private int a = 0;
private int b = 0;

public static void main(String[] args) throws InterruptedException,
ExecutionException {
ReorderTest rt = new ReorderTest();
rt.doTest();
}

public void doTest() throws InterruptedException, ExecutionException {
ExecutorService executor = Executors.newFixedThreadPool(2);

//可能出现的结果（关注ThreadATask，ThreadBTask取到的结果）
int num00 = 0; //x=0，y=0
int num10 = 0; //x=1，y=0
int num02 = 0; //x=0，y=2
int num12 = 0; //x=1，y=2

//可能出现的结果（关注主线程取到的结果）
int main00_a = 0;
int main10_a = 0;
int main02_a = 0;
int main12_a = 0;

//可能出现的结果（关注主线程取到的结果）
int main00_b = 0;
int main10_b = 0;
int main02_b = 0;
int main12_b = 0;

int allNum = 100000;
for (int i = 0; i < allNum; i++) {

CountDownLatch latch = new CountDownLatch(1);
Future futureA = executor.submit(new ThreadATask(latch));
Future futureB = executor.submit(new ThreadBTask(latch));
latch.countDown();
if (a==0 && b==0) {main00_a++;}
if (a==1 && b==0) {main10_a++;}
if (a==0 && b==2) {main02_a++;}
if (a==1 && b==2) {main12_a++;}

int x = (Integer) futureB.get(); //取得a
int y = (Integer) futureA.get(); //取得b

if (x==0 && y==0) {num00++;}
if (x==1 && y==0) {num10++;}
if (x==0 && y==2) {num02++;}
if (x==1 && y==2) {num12++;}

if (a==0 && b==0) {main00_b++;}
if (a==1 && b==0) {main10_b++;}
if (a==0 && b==2) {main02_b++;}
if (a==1 && b==2) {main12_b++;}

//重置状态
a = 0;
b = 0;
}
System.out.println("a=0，b=0出现次数：" + main00_a);
System.out.println("a=1，b=0出现次数：" + main10_a);
System.out.println("a=0，b=2出现次数：" + main02_a);
System.out.println("a=1，b=2出现次数：" + main12_a);

System.out.println("");
System.out.println("x=0，y=0出现次数：" + num00);
System.out.println("x=1，y=0出现次数：" + num10);
System.out.println("x=0，y=2出现次数：" + num02);
System.out.println("x=1，y=2出现次数：" + num12);

System.out.println("");
System.out.println("a=0，b=0出现次数：" + main00_b);
System.out.println("a=1，b=0出现次数：" + main10_b);
System.out.println("a=0，b=2出现次数：" + main02_b);
System.out.println("a=1，b=2出现次数：" + main12_b);
executor.shutdown();
}

private class ThreadATask implements Callable {
private CountDownLatch barrier;

public ThreadATask(CountDownLatch barrier) {
this.barrier = barrier;
}

public Integer call() throws InterruptedException,
BrokenBarrierException {
barrier.await(); //

a = 1; // A1
return b; // A2
}
}

private class ThreadBTask implements Callable {
private CountDownLatch barrier;

public ThreadBTask(CountDownLatch barrier) {
this.barrier = barrier;
}

public Integer call() throws InterruptedException,
BrokenBarrierException {
barrier.await();

b = 2; // B1
return a; // B2
}
}
}

你好，对于这一系列文章看了好多遍了，还是不太明白happens-before，假如一个方法中只有两句代码为:this.a=10;int b=20;根据文中指令级排序中说到的“如果不存在数据依赖性，处理器可以改变语句对应机器指令的执行顺序”，那么对于这两句代码而言确实不存在数据依赖性，则处理器就有可能对这两句代码做重排序，先执行int b=20;再执行this.a=10，然后对于文中提到的”程序顺序规则：一个线程中的每个操作，happens- before 于该线程中的任意后续操作”，说明这两个操作之间存在happens- before关系， 虽然happens- before 规则不要求this.a=10一定要在int b=20之前执行，也就符合了处理器对这两个操作做重排序的做法，但是happens- before 却要求”前一个操作（执行的结果）对后一个操作可见”，那么这里的两个操作被处理器重排序过后，this.a=10的操作结果并不一定对int b=20这个操作可见啊！这个是不是矛盾了啊？可能是我的理解出现了错误，还请兄台不吝赐教！谢谢！

写的不错

nice

你好，我有一个疑问，比如在一个类中有一个volatile修饰的变量，然后有两个线程A，B分别对这个变量进行读写操作，那么B线程对该变量的写的结果一定能够被线程A看到吗？也就是说，如果线程B在写入该变量之前要运行100ms其他的一些代码，而线程A在线程B写入操作之前已经运行到自己的读操作，那此时线程A会停下来等待线程B的写入操作呢？还是继续运行，并读取此时该变量的值？

引用”由于现代的processor都会使用写缓冲区，因此现代的processor都会允许对写-读操作重排序。”,为什么所有的processor都支持写-读重排序,不支持读-读重排序呢?读-读不应该更不会影响最终结果的正确性吗?

引用”StoreLoad Barriers会使该屏障之前的所有内存访问指令（存储和装载指令）完成之后，才执行该屏障之后的内存访问指令。”本人理解的StoreLoad Barriers只是写-读内存屏障,为什么从这句话中读到的意思是读-读,写-读操作呢?后还提到具备3个内存屏障的效果是什么意思?

文章说 ： 在共享内存并发模型里，同步是显式进行的。程序员必须显式指定某个方法或某段代码需要在线程之间互斥执行。在消息传递的并发模型里，由于消息的发送必须在消息的接收之前，因此同步是隐式进行的。

为什么又说 Java的并发采用的是共享内存模型，Java线程之间的通信总是隐式进行，

不是说消息传递的并发模型里，才是隐式进行的吗。

文中多次提到处理器写缓冲，因此造成一些列的重排序可见性问题，我想问的是，处理器再从内存读取数据时会有读缓冲吗？比如A线程读取了变量i, 此后B线程修改了变量i并写入了主存，此时A线程再次读取变量i时，它是从主存读呢还是读取缓存呢？

“这里处理器A和处理器B可以同时把共享变量写入自己的写缓冲区（A1，B1），然后从内存中读取另一个共享变量（A2，B2），最后才把自己写缓存区中保存的脏数据刷新到内存中（A3，B3）。当以这种时序执行时，程序就可以得到x = y = 0的结果。
从内存操作实际发生的顺序来看，直到处理器A执行A3来刷新自己的写缓存区，写操作A1才算真正执行了。虽然处理器A执行内存操作的顺序为：A1->A2，但内存操作实际发生的顺序却是：A2->A1。此时，处理器A的内存操作顺序被重排序了（处理器B的情况和处理器A一样，这里就不赘述了）”

你好，有一点有疑问，关于这个x=y=0的case，应该不会发生吧？根据缓存一致性协议，在修改缓存中a或者b的值，会导致其他的cpu缓存失效啊，然后会从主存重新读，这会触发缓存中的a或者b会刷新到主存，所以，重新读读取到的肯定是修改后的值，然后再复制给x或者y。不知道我这样理解对不对