【Java并发】线程安全和内存模型

• 四、threadlocal
  • 4.1 什么是threadlocal
  • 4.3 threadloca实现原理
• 五、java内存模型
  • 5.4 volatile
    • 1. 什么是volatile

一、概述

1.1 什么是线程安全？

• 当多个线程同时共享，同一个全局变量或静态变量，做写的操作时，可能会发生数据冲突问题，也就是线程安全问题。但是做读操作是不会发生数据冲突问题。

1.2 案例

• 需求现在有100张火车票，有两个窗口同时抢火车票，请使用多线程模拟抢票效果。

代码

public class threadtrain implements runnable {
    private int traincount = 100;
    
    @override
    public void run() {
        while (traincount > 0) {
            try {
                thread.sleep(50);
            } catch (exception e) {
    
            }
            sale();
        }
    }
    
    public void sale() {
        if (traincount > 0) {
            system.out.println(thread.currentthread().getname() + ",出售第" + (100 - traincount + 1) + "张票");
            traincount--;
        }
    }
    
    public static void main(string[] args) {
        threadtrain threadtrain = new threadtrain();
        thread t1 = new thread(threadtrain, "①号");
        thread t2 = new thread(threadtrain, "②号");
        t1.start();
        t2.start();
    }
    
}

运行结果

• 一号窗口和二号窗口同时出售火车第77张,部分火车票会重复出售。
• 结论发现，多个线程共享同一个全局成员变量时，做写的操作可能会发生数据冲突问题。

1.3 线程安全解决办法:

• 使用多线程之间同步synchronized或使用锁(lock)。将可能会发生数据冲突问题(线程不安全问题)，只能让当前一个线程进行执行。代码执行完成后释放锁，让后才能让其他线程进行执行。这样的话就可以解决线程不安全问题。当多个线程共享同一个资源,不会受到其他线程的干扰。

二、synchronized

2.1 概述

• java提供了一种内置的锁机制来支持原子性
• 每一个java对象都可以用作一个实现同步的锁，称为内置锁，线程进入同步代码块之前自动获取到锁，代码块执行完成正常退出或代码块中抛出异常退出时会释放掉锁
• 内置锁为互斥锁，即线程a获取到锁后，线程b阻塞直到线程a释放锁，线程b才能获取到同一个锁
• 内置锁使用synchronized关键字实现，synchronized关键字有两种用法：
  • 1.修饰需要进行同步的方法（所有访问状态变量的方法都必须进行同步），此时充当锁的对象为调用同步方法的对象
  • 2.同步代码块和直接使用synchronized修饰需要同步的方法是一样的，但是锁的粒度可以更细，并且充当锁的对象不一定是this，也可以是其它对象，所以使用起来更加灵活

2.2 同步代码块

• 就是将可能会发生线程安全问题的代码，给包括起来。格式如下：

synchronized(对象) { //这个对象可以为任意对象
    需要被同步的代码 
} 

• 对象如同锁，持有锁的线程可以在同步中执行，没持有锁的线程即使获取cpu的执行权，也进不去
• 同步的前提：
• 1，必须要有两个或者两个以上的线程
• 2，必须是多个线程使用同一个锁
• 必须保证同步中只能有一个线程在运行
• 好处：解决了多线程的安全问题
• 弊端：多个线程需要判断锁，较为消耗资源

代码样例

• 将上面的例子中的sale()方法加锁

public void sale() {
    synchronized (this) {
        if (traincount > 0) {
            system.out.println(thread.currentthread().getname() + ",出售第" + (100 - traincount + 1) + "张票");
            traincount--;
        }
    }
}

2.3 同步方法

• 在方法上修饰synchronized 称为同步方法，

代码样例

public synchronized void sale() {
    if (traincount > 0) {
        system.out.println(thread.currentthread().getname() + ",出售第" + (100 - traincount + 1) + "张票");
        traincount--;
    }
}

• 同步函数使用this锁。注意这里是非静态的普通方法
• 证明方式: 一个线程使用同步代码块(this明锁),另一个线程使用同步函数。如果两个线程抢票不能实现同步，那么会出现数据错误。

代码如下

/**
 * 
 * 测试 同步方法(非静态) 的锁是 this 对象
 * @author hao
 *
 */
public class test_syncfun {
    public static void main(string[] args) throws interruptedexception {
        mythread threadtrain = new mythread();
        thread t1 = new thread(threadtrain, "窗口1");
        thread t2 = new thread(threadtrain, "窗口2");
        t1.start();
        thread.sleep(40);
        threadtrain.flag = false;
        t2.start();

    }
}

class mythread implements runnable {
    private int traincount = 100;
    private object oj = new object();
    public boolean flag = true;

    public void run() {
        if (flag) {
            while (traincount > 0) {
                synchronized (this) {
                    try {
                        thread.sleep(10);
                    } catch (exception e) {
                        // todo: handle exception
                    }
                    if (traincount > 0) {
                        system.out.println(thread.currentthread().getname() + "," 
                                        + "出售第" + (100 - traincount + 1) + "票");
                        traincount--;
                    }
                }

            }
        } else {
            while (traincount > 0) {
                sale();
            }

        }

    }

    public synchronized void sale() {
        try {
            thread.sleep(10);
        } catch (exception e) {
            // todo: handle exception
        }
        if (traincount > 0) {
            system.out.println(thread.currentthread().getname() + "," 
                                + "出售第" + (100 - traincount + 1) + "票");
            traincount--;
        }

    }
}

2.4 静态同步函数

• synchronized 关键字修饰 静态方法
• 静态的同步函数使用的锁是 该函数所属字节码文件对象
• 可以用 getclass方法获取，也可以用当前 类名.class 表示。

代码样例

public static synchronized  void sale() {
        if (traincount > 0) {
            system.out.println(thread.currentthread().getname() + ",出售第" + (100 - traincount + 1) + "张票");
            traincount--;
        }   
}

//上面的就等同于如下代码块，锁对象为当前类的字节码文件对象

public static void sale() {
        synchronized (threadtrain.class) {
            if (traincount > 0) {
                system.out.println(thread.currentthread().getname() + ",出售第" + (100 - traincount + 1) + "张票");
                traincount--;
            }
        }
}

2.5 总结

• synchronized 修饰普通方法使用锁是当前this锁。
• synchronized 修饰静态方法使用锁是当前类的字节码文件

三、多线程死锁

3.1 什么是死锁

• 同步中嵌套同步,导致锁无法释放
• 多个线程同时被阻塞，它们中的一个或者全部都在等待某个资源被释放。由于线程被无限期地阻塞，因此程序不可能正常终止。
• 线程 a 持有资源 2，线程 b 持有资源 1，他们同时都想申请对方的资源，所以这两个线程就会互相等待而进入死锁状态。

示例

/**
 * 死锁
 *
 */
public class deadlockdemo {
    private static object resource1 = new object();//资源 1
    private static object resource2 = new object();//资源 2

    public static void main(string[] args) {
        new thread(() -> {
            synchronized (resource1) {
                system.out.println(thread.currentthread() + "get resource1");
                try {
                    thread.sleep(1000);
                } catch (interruptedexception e) {
                    e.printstacktrace();
                }
                system.out.println(thread.currentthread() + "waiting get resource2");
                synchronized (resource2) {
                    system.out.println(thread.currentthread() + "get resource2");
                }
            }
        }, "线程 1").start();

        new thread(() -> {
            synchronized (resource2) {
                system.out.println(thread.currentthread() + "get resource2");
                try {
                    thread.sleep(1000);
                } catch (interruptedexception e) {
                    e.printstacktrace();
                }
                system.out.println(thread.currentthread() + "waiting get resource1");
                synchronized (resource1) {
                    system.out.println(thread.currentthread() + "get resource1");
                }
            }
        }, "线程 2").start();
    }
}

• 线程 a 通过 synchronized (resource1) 获得 resource1 的监视器锁，然后通过thread.sleep(1000);让线程 a 休眠 1s 为的是让线程 b 得到执行然后获取到 resource2 的监视器锁。线程 a 和线程 b 休眠结束了都开始企图请求获取对方的资源，然后这两个线程就会陷入互相等待的状态，这也就产生了死锁。上面的例子符合产生死锁的四个必要条件。

• 操作系统中产生死锁必须具备以下四个条件：

  • 互斥条件：该资源任意一个时刻只由一个线程占用。
  • 请求与保持条件：一个进程因请求资源而阻塞时，对已获得的资源保持不放。
  • 不剥夺条件:线程已获得的资源在末使用完之前不能被其他线程强行剥夺，只有自己使用完毕后才释放资源。
  • 循环等待条件:若干进程之间形成一种头尾相接的循环等待资源关系。

3.2 如何避免

• 我们只要破坏产生死锁的四个条件中的其中一个就可以了。
• 破坏互斥条件
  • 这个条件我们没有办法破坏，因为我们用锁本来就是想让他们互斥的（临界资源需要互斥访问）。
• 破坏请求与保持条件
  • 一次性申请所有的资源。
• 破坏不剥夺条件
  • 占用部分资源的线程进一步申请其他资源时，如果申请不到，可以主动释放它占有的资源。

• 破坏循环等待条件

  • 靠按序申请资源来预防。按某一顺序申请资源，释放资源则反序释放。破坏循环等待条件。

• 我们对线程 2 的代码修改成下面这样就不会产生死锁了。

new thread(() -> {
            synchronized (resource1) {
                system.out.println(thread.currentthread() + "get resource1");
                try {
                    thread.sleep(1000);
                } catch (interruptedexception e) {
                    e.printstacktrace();
                }
                system.out.println(thread.currentthread() + "waiting get resource2");
                synchronized (resource2) {
                    system.out.println(thread.currentthread() + "get resource2");
                }
            }
        }, "线程 2").start();

分析

• 线程 1 首先获得到 resource1 的监视器锁,这时候线程 2 就获取不到了。然后线程 1 再去获取 resource2 的监视器锁，可以获取到。然后线程 1 释放了对 resource1、resource2 的监视器锁的占用，线程 2 获取到就可以执行了。这样就破坏了破坏循环等待条件，因此避免了死锁。

四、threadlocal

4.1 什么是threadlocal

• threadlocal提高一个线程的局部变量，访问某个线程拥有自己局部变量。
• 当使用threadlocal维护变量时，threadlocal为每个使用该变量的线程提供独立的变量副本，所以每一个线程都可以独立地改变自己的副本，而不会影响其它线程所对应的副本。
• 比如有两个人去宝屋收集宝物，这两个共用一个袋子的话肯定会产生争执，但是给他们两个人每个人分配一个袋子的话就不会出现这样的问题。如果把这两个人比作线程的话，那么threadlocal就是用来避免这两个线程竞争的。
• threadlocal的接口方法,threadlocal类接口很简单，只有4个方法，我们先来了解一下：
  • void set(object value) , 设置当前线程的线程局部变量的值。
  • public object get() , 该方法返回当前线程所对应的线程局部变量。
  • public void remove() , 将当前线程局部变量的值删除，目的是为了减少内存的占用，该方法是jdk 5.0新增的方法。需要指出的是，当线程结束后，对应该线程的局部变量将自动被垃圾回收，所以显式调用该方法清除线程的局部变量并不是必须的操作，但它可以加快内存回收的速度。
  • protected object initialvalue() , 返回该线程局部变量的初始值，该方法是一个protected的方法，显然是为了让子类覆盖而设计的。这个方法是一个延迟调用方法，在线程第1次调用get()或set(object)时才执行，并且仅执行1次。threadlocal中的缺省实现直接返回一个null。

4.2 案例

• 创建三个线程，每个线程生成自己独立序列号。

package com.hao.threadlocal;

public class threadlocademo extends thread {
    private res res;
    public threadlocademo(res res) {
        this.res = res;
    }

    @override
    public void run() {
        for (int i = 0; i < 3; i++) {
            system.out.println(thread.currentthread().getname() + "---" + "i---" + i + "--num:" + res.getnum());
        }

    }

    public static void main(string[] args) {
        res res = new res();
        threadlocademo threadlocademo1 = new threadlocademo(res);
        threadlocademo threadlocademo2 = new threadlocademo(res);
        threadlocademo threadlocademo3 = new threadlocademo(res);
        threadlocademo1.start();
        threadlocademo2.start();
        threadlocademo3.start();
    }

}

class res {
    // 生成序列号共享变量
    public static integer count = 0;
    public static threadlocal<integer> threadlocal = new threadlocal<integer>() {
        protected integer initialvalue() {
            return 0;
        };
    };

    public integer getnum() {
        int count = threadlocal.get() + 1;
        threadlocal.set(count);
        return count;
    }
}

运行结果 可以看出每个线程会自己生成num，互不干扰

thread-1---i---0--num:1
thread-2---i---0--num:1
thread-0---i---0--num:1
thread-2---i---1--num:2
thread-1---i---1--num:2
thread-2---i---2--num:3
thread-1---i---2--num:3
thread-0---i---1--num:2
thread-0---i---2--num:3

4.3 threadloca实现原理

• 最终的变量是放在了当前线程的 threadlocalmap 中，并不是存在 threadlocal 上，threadlocal 可以理解为只是threadlocalmap的封装，传递了变量值。 threallocal 类中可以通过thread.currentthread()获取到当前线程对象后，直接通过getmap(thread t)可以访问到该线程的threadlocalmap对象。

• 每个thread中都具备一个threadlocalmap，而threadlocalmap可以存储以threadlocal为key的键值对。threadlocalmap的 key 就是 threadlocal对象，value 就是 threadlocal 对象调用set方法设置的值。threadlocal 是 map结构是为了让每个线程可以关联多个 threadlocal变量。这也就解释了 threadlocal 声明的变量为什么在每一个线程都有自己的专属本地变量。

4.4 内存泄漏问题

• threadlocalmap 中使用的 key 为 threadlocal 的弱引用,而 value 是强引用。所以，如果 threadlocal 没有被外部强引用的情况下，在垃圾回收的时候会 key 会被清理掉，而 value 不会被清理掉。这样一来，threadlocalmap 中就会出现key为null的entry。假如我们不做任何措施的话，value 永远无法被gc 回收，这个时候就可能会产生内存泄露。threadlocalmap实现中已经考虑了这种情况，在调用 set()、get()、remove() 方法的时候，会清理掉 key 为 null 的记录。使用完 threadlocal方法后 最好手动调用remove()方法

static class entry extends weakreference<threadlocal<?>> {
    /** the value associated with this threadlocal. */
    object value;

    entry(threadlocal<?> k, object v) {
        super(k);
        value = v;
    }
}

关于弱引用

• 如果一个对象只具有弱引用，那就类似于可有可无的生活用品。弱引用与软引用的区别在于：只具有弱引用的对象拥有更短暂的生命周期。在垃圾回收器线程扫描它 所管辖的内存区域的过程中，一旦发现了只具有弱引用的对象，不管当前内存空间足够与否，都会回收它的内存。不过，由于垃圾回收器是一个优先级很低的线程， 因此不一定会很快发现那些只具有弱引用的对象。

• 弱引用可以和一个引用队列（referencequeue）联合使用，如果弱引用所引用的对象被垃圾回收，java虚拟机就会把这个弱引用加入到与之关联的引用队列中。

五、java内存模型

5.1 主内存和工作内存

• 处理器上的寄存器的读写的速度比内存快几个数量级，为了解决这种速度矛盾，在它们之间加入了高速缓存。
• 加入高速缓存带来了一个新的问题：缓存一致性。如果多个缓存共享同一块主内存区域，那么多个缓存的数据可能会不一致，需要一些协议来解决这个问题。
• 共享内存模型指的就是java内存模型(简称jmm)，jmm决定一个线程对共享变量的写入时,能对另一个线程可见。从抽象的角度来看，jmm定义了线程和主内存之间的抽象关系：线程之间的共享变量存储在主内存（main memory）中，每个线程都有一个私有的本地内存（local memory），本地内存中存储了该线程以读/写共享变量的副本。本地内存是jmm的一个抽象概念，并不真实存在。它涵盖了缓存，写缓冲区，寄存器以及其他的硬件和编译器优化。

• 从上图来看，线程a与线程b之间如要通信的话，必须要经历下面2个步骤
• 首先，线程a把本地内存a中更新过的共享变量刷新到主内存中去。

• 然后，线程b到主内存中去读取线程a之前已更新过的共享变量。

• 下面通过示意图来说明这两个步骤：

• 如上图所示，本地内存a和b有主内存*享变量x的副本。假设初始时，这三个内存中的x值都为0。线程a在执行时，把更新后的x值（假设值为1）临时存放在自己的本地内存a中。当线程a和线程b需要通信时，线程a首先会把自己本地内存中修改后的x值刷新到主内存中，此时主内存中的x值变为了1。随后，线程b到主内存中去读取线程a更新后的x值，此时线程b的本地内存的x值也变为了1。

• 从整体来看，这两个步骤实质上是线程a在向线程b发送消息，而且这个通信过程必须要经过主内存。jmm通过控制主内存与每个线程的本地内存之间的交互，来为java程序员提供内存可见性保证。

• 总结：什么是java内存模型：java内存模型简称jmm，定义了一个线程对另一个线程可见。共享变量存放在主内存中，每个线程都有自己的本地内存，当多个线程同时访问一个数据的时候，可能本地内存没有及时刷新到主内存，所以就会发生线程安全问题。

5.2 内存间交互操作

• java 内存模型定义了 8 个操作来完成主内存和工作内存的交互操作。

• read (读取) :作用于主内存的变量，它把一个变量的值从主内存传输到线程的工作内存中，以便随后的load动作使用。
• load (载入):作用于工作内存的变量，它把read操作从主内存中得到的变量值放人工作内存的变量副本中。
• use (使用):作用于工作内存的变量，它把工作内存中一个变量的值传递给执行引擎,每当虚拟机遇到一个需要使用到变量的值的字节码指令时将会执行这个操作。
• assign (赋值):作用于工作内存的变量，它把一个从执行引擎接收到的值赋给工作内存的变量，每当虚拟机遇到一个给变量赋值的字节码指令时执行这个操作。
• store (存储) :作用于工作内存的变量，它把工作内存中一个变量的值传送到主内存中，以便随后的write操作使用。
• write (写入):作用于主内存的变量，它把store操作从工作内存中得到的变量的值放人主内存的变量中。
• lock (锁定):作用于主内存的变量，它把一个变量标识为-条线程独占的状态。
• unlock (解锁):作用于主内存的变量，它把一个处于锁定状态的变量释放出来，释放后的变量才可以被其他线程锁定。

5.3 多线程有三大特性

1. 原子性

• 即一个操作或者多个操作 要么全部执行并且执行的过程不会被任何因素打断，要么就都不执行。
• 一个很经典的例子就是银行账户转账问题：
• 比如从账户a向账户b转1000元，那么必然包括2个操作：从账户a减去1000元，往账户b加上1000元。这2个操作必须要具备原子性才能保证不出现一些意外的问题。
• 我们操作数据也是如此，比如i = i+1；其中就包括，读取i的值，计算i，写入i。这行代码在java中是不具备原子性的，则多线程运行肯定会出问题，所以也需要我们使用同步和lock这些东西来确保这个特性了。
• 原子性其实就是保证数据一致、线程安全一部分，

2. 什么是可见性

• 当多个线程访问同一个变量时，一个线程修改了这个变量的值，其他线程能够立即看得到修改的值。
• 若两个线程在不同的cpu，那么线程1改变了i的值还没刷新到主存，线程2又使用了i，那么这个i值肯定还是之前的，线程1对变量的修改线程没看到这就是可见性问题。

3. 什么是有序性

• 程序执行的顺序按照代码的先后顺序执行。
• 一般来说处理器为了提高程序运行效率，可能会对输入代码进行优化，它不保证程序中各个语句的执行先后顺序同代码中的顺序一致，但是它会保证程序最终执行结果和代码顺序执行的结果是一致的。如下：

int a = 10;    //语句1
int r = 2;    //语句2
a = a + 3;    //语句3
r = a*a;     //语句4

• 因为重排序，他还可能执行顺序为 2-1-3-4，1-3-2-4
• 但绝不可能 2-1-4-3，因为这打破了依赖关系,语句4不能再其他语句之前。
• 显然重排序对单线程运行是不会有任何问题，而多线程就不一定了，所以我们在多线程编程时就得考虑这个问题了。

5.4 volatile

1. 什么是volatile

• 可见性也就是说一旦某个线程修改了该被volatile修饰的变量，它会保证修改的值会立即被更新到主存，当有其他线程需要读取时，可以立即获取修改之后的值。
• 在java中为了加快程序的运行效率，对一些变量的操作通常是在该线程的寄存器或是cpu缓存上进行的，之后才会同步到主存中，而加了volatile修饰符的变量则是直接读写主存。
• volatile 保证了线程间共享变量的及时可见性，但不能保证原子性

2. 代码

class threadvolatiledemo extends thread {
    public boolean flag = true;
    @override
    public void run() {
        system.out.println("开始执行子线程....");
        while (flag) {
        }
        system.out.println("线程停止");
    }
    public void setruning(boolean flag) {
        this.flag = flag;
    }
    
}
    
public class threadvolatile {
    public static void main(string[] args) throws interruptedexception {
        threadvolatiledemo threadvolatiledemo = new threadvolatiledemo();
        threadvolatiledemo.start();
        thread.sleep(3000);
        threadvolatiledemo.setruning(false);
        system.out.println("flag 已经设置成false");
        thread.sleep(1000);
        system.out.println(threadvolatiledemo.flag);
    }
}

运行结果

• 已经将结果设置为fasle为什么？还一直在运行呢。
• 原因:线程之间是不可见的，读取的是副本，没有及时读取到主内存结果。
• 解决办法使用volatile关键字将解决线程之间可见性, 强制线程每次读取该值的时候都去“主内存”中取值

3. volatile特性

1. 保证此变量对所有的线程的可见性，这里的“可见性”，当一个线程修改了这个变量的值，volatile 保证了新值能立即同步到主内存，以及每次使用前立即从主内存刷新。但普通变量做不到这点，普通变量的值在线程间传递均需要通过主内存（详见：java内存模型）来完成。
2. 禁止指令重排序优化。有volatile修饰的变量，赋值后多执行了一个“load addl $0x0, (%esp)”操作，这个操作相当于一个内存屏障（指令重排序时不能把后面的指令重排序到内存屏障之前的位置），只有一个cpu访问内存时，并不需要内存屏障；（什么是指令重排序：是指cpu采用了允许将多条指令不按程序规定的顺序分开发送给各相应电路单元处理）。

4. volatile 性能：

• volatile 的读性能消耗与普通变量几乎相同，但是写操作稍慢，因为它需要在本地代码中插入许多内存屏障指令来保证处理器不发生乱序执行。

5. volatile与synchronized区别

• （1）我们可以看出volatile虽然具有可见性但是并不能保证原子性。
• （2）性能方面，synchronized关键字是防止多个线程同时执行一段代码，就会影响程序执行效率，而volatile关键字在某些情况下性能要优于synchronized。但是要注意volatile关键字是无法替代synchronized关键字的，因为volatile关键字无法保证操作的原子性。

5.5 重排序

1. 数据依赖性

• 如果两个操作访问同一个变量，且这两个操作中有一个为写操作，此时这两个操作之间就存在数据依赖性。数据依赖分下列三种类型：
• 名称　　　代码示例　　　　　　说明
• 写后读　　a = 1;b = a;　　　写一个变量之后，再读这个位置。
• 写后写　　a = 1;a = 2;　　　写一个变量之后，再写这个变量。

• 读后写　　a = b;b = 1;　　　读一个变量之后，再写这个变量。

• 上面三种情况，只要重排序两个操作的执行顺序，程序的执行结果将会被改变。

• 前面提到过，编译器和处理器可能会对操作做重排序。编译器和处理器在重排序时，会遵守数据依赖性，编译器和处理器不会改变存在数据依赖关系的两个操作的执行顺序。

• 注意，这里所说的数据依赖性仅针对单个处理器中执行的指令序列和单个线程中执行的操作，不同处理器之间和不同线程之间的数据依赖性不被编译器和处理器考虑。

2. as-if-serial语义

• as-if-serial语义的意思指：不管怎么重排序（编译器和处理器为了提高并行度），（单线程）程序的执行结果不能被改变。编译器，runtime 和处理器都必须遵守as-if-serial语义。
• 为了遵守as-if-serial语义，编译器和处理器不会对存在数据依赖关系的操作做重排序，因为这种重排序会改变执行结果。但是，如果操作之间不存在数据依赖关系，这些操作可能被编译器和处理器重排序。为了具体说明，请看下面计算圆面积的代码示例：

double pi  = 3.14;    //a
double r   = 1.0;     //b
double area = pi * r * r; //c

• 上面三个操作的数据依赖关系如下图所示：

• 如上图所示，a和c之间存在数据依赖关系，同时b和c之间也存在数据依赖关系。
• 因此在最终执行的指令序列中，c不能被重排序到a和b的前面（c排到a和b的前面，程序的结果将会被改变）。

• 但a和b之间没有数据依赖关系，编译器和处理器可以重排序a和b之间的执行顺序。下图是该程序的两种执行顺序：

  

  as-if-serial语义把单线程程序保护了起来，遵守as-if-serial语义的编译器，runtime 和处理器共同为编写单线程程序的程序员创建了一个幻觉：单线程程序是按程序的顺序来执行的。
  as-if-serial语义使单线程程序员无需担心重排序会干扰他们，也无需担心内存可见性问题。

3. 程序顺序规则

• 根据happens- before的程序顺序规则，上面计算圆的面积的示例代码存在三个happens- before关系：

1. a happens- before b；
2. b happens- before c；

3. a happens- before c；

• 这里的第3个happens- before关系，是根据happens- before的传递性推导出来的。
• 这里a happens- before b，但实际执行时b却可以排在a之前执行（看上面的重排序后的执行顺序）。
• 如果a happens- before b，jmm并不要求a一定要在b之前执行。jmm仅仅要求前一个操作（执行的结果）对后一个操作可见，且前一个操作按顺序排在第二个操作之前。这里操作a的执行结果不需要对操作b可见；而且重排序操作a和操作b后的执行结果，与操作a和操作b按happens- before顺序执行的结果一致。
• 在这种情况下，jmm会认为这种重排序并不非法（not illegal），jmm允许这种重排序。在计算机中，软件技术和硬件技术有一个共同的目标：在不改变程序执行结果的前提下，尽可能的开发并行度。
• 编译器和处理器遵从这一目标，从happens- before的定义我们可以看出，jmm同样遵从这一目标。

4. 重排序对多线程的影响

• 现在让我们来看看，重排序是否会改变多线程程序的执行结果。请看下面的示例代码：

class reorderexample {
    int a = 0;
    boolean flag = false;
        
    public void writer() {
        a = 1;                   //1
        flag = true;             //2
    }
        
    public void reader() {
        if (flag) {                //3
            int i =  a * a;        //4
            ……
        }
    }
}

• flag变量是个标记，用来标识变量a是否已被写入。这里假设有两个线程a和b，a首先执行writer()方法，随后b线程接着执行reader()方法。线程b在执行操作4时，能否看到线程a在操作1对共享变量a的写入？
• 答案是：不一定能看到。

• 由于操作1和操作2没有数据依赖关系，编译器和处理器可以对这两个操作重排序；同样，操作3和操作4没有数据依赖关系，编译器和处理器也可以对这两个操作重排序。让我们先来看看，当操作1和操作2重排序时，可能会产生什么效果？请看下面的程序执行时序图：

  

• 如上图所示，操作1和操作2做了重排序。程序执行时，线程a首先写标记变量flag，随后线程b读这个变量。由于条件判断为真，线程b将读取变量a。此时，变量a还根本没有被线程a写入，在这里多线程程序的语义被重排序破坏了！

• 下面再让我们看看，当操作3和操作4重排序时会产生什么效果（借助这个重排序，可以顺便说明控制依赖性）。下面是操作3和操作4重排序后，程序的执行时序图：

• 在程序中，操作3和操作4存在控制依赖关系。当代码中存在控制依赖性时，会影响指令序列执行的并行度。为此，编译器和处理器会采用猜测（speculation）执行来克服控制相关性对并行度的影响。以处理器的猜测执行为例，执行线程b的处理器可以提前读取并计算aa，然后把计算结果临时保存到一个名为重排序缓冲（reorder buffer rob）*的硬件缓存中。当接下来操作3的条件判断为真时，就把该计算结果写入变量i中。
• 从图中我们可以看出，猜测执行实质上对操作3和4做了重排序。重排序在这里破坏了多线程程序的语义！
• 在单线程程序中，对存在控制依赖的操作重排序，不会改变执行结果（这也是as-if-serial语义允许对存在控制依赖的操作做重排序的原因）；
• 但在多线程程序中，对存在控制依赖的操作重排序，可能会改变程序的执行结果。