1,程序真的是按照顺序执行的吗，看看下边的小程序再说话，哈哈
package com.yang.Threads;
import java.util.concurrent.CountDownLatch;
/**
* @Author: Gy
* @Description:
* @Date
* @Modified By:
*/
public class TestOrdering {
private static int a = 0, b = 0;
private static int x = 0, y = 0;
public static void main(String[] args) throws InterruptedException {
for (long i = 0; i < Long.MAX_VALUE; i++) {
x = 0;
y = 0;
a = 0;
b = 0;
CountDownLatch countDownLatch = new CountDownLatch(2);
Thread thread1 = new Thread(() -> {
a = 1;
x = b;
countDownLatch.countDown();
});
Thread thread2 = new Thread(() -> {
b = 1;
y = a;
countDownLatch.countDown();
});
thread1.start();
thread2.start();
countDownLatch.await();
if (x == 0 && y == 0){
System.out.println("第"+i+"次结果为("+x+","+y+")");
break;
}
}
}
}
经过多次演示终于得到了想要的控制台结果如下：
2、为什么会出现以上结果呢？如果程序是按照顺序执行的，肯定不会出现x和y同时为0的情况，答案显然是thread1先执行了x = b,thread2先执行了y = a,只有这两个条件同时满足才会出现控制台的结果，也就是说程序中前后两个没有依赖关系的语句有一定的概率会交换顺序执行，即使概率很低，但也是确确实实存在的，不管是多线程还是单线程的程序，都存在这样的概率事件
3、为什么存在乱序呢
原因是为了提高cpu的执行效率，我们知道每条java语句最终都会被转化为汇编指令去cpu执行，比较费时的指令我们叫指令a，不费时的指令我们叫指令b,cpu在执行指令a的时候不会傻傻的等待响应，而是可以利用原本的等待指令a的时间，去执行指令b,由于指令b用时很短，所有就会出现先运行完指令b，再运行完指令a的现象，也就是乱序
4、乱序存在的条件，哪种情况下允许出现乱序呢？
上面稍微提到过，前后两条没有依赖关系的语句才允许出现乱序，因为不影响单线程的最终一致性，但是在多线程中可能是有影响的，例如上面示例代码中，thread1中两个变量的定义顺序不影响thread1的执行结果，同样thread2也是如此，因为两个变量之间没有依赖关系，自己玩自己的，互不影响。再说说有依赖关系的语句，比如int x = 0; x++;这两条语句，显然不能调用执行顺序，否则会影响单线程的最终一致性。
5、看下边的一个示例，考察了线程的可见性和有序性，猜测一下num最终的结果是什么
package com.yang.Threads;
/**
* @Author: Gy
* @Description:
* @Date
* @Modified By:
*/
public class TestOrdering2 implements Runnable{
private static /*volatile*/ boolean ready = false;
private static int num;
@Override
public void run() {
while (!ready){
Thread.yield();
}
System.out.println("num最终的值为："+num);
}
public static void main(String[] args) throws InterruptedException {
Thread thread1 = new Thread(new TestOrdering2());
thread1.start();
num = 22;
ready = true;
thread1.join();
}
}
以上程序分析：为了保证共享变量在线程间的可见性，严谨的写法应该用volatile修饰ready变量，但是该程序没有使用volatile也可以保证可见性，原因是thread1中的yield()方法会触发缓存同步，及时获取到了主线程中设置的true,还有一个原因是MESI(Intel cpu)缓存一致性协议的主动性使得thread1能及时更新主线程中更改过的ready值。
输出的num值有可能是22，也有可能是默认值0，因为根据单线程的最终一致性，num和ready两条语句没有依赖关系，所有在执行的时候，是有一定的概率打乱顺序的，如果打乱顺序，就先执行了ready = true然后子线程发现了共享变量被修改，输出默认值0。
6.图解对象创建过程,以user.java为例
package com.yang.bootmongo.entity;
import lombok.Data;
@Data
public class User {
private int age = 8;
// private int id;
// private String name;
public static void main(String[] args) {
User user = new User();
}
}
通过IDEA查看 User user = new User();的bytecode汇编指令，见下图
-
第一步 调用new User()，首先申请内存，成员变量赋默认值,即age = 0 。（此时是对象的半初始化状态）
-
-
第二步 调用构造方法，成员变量赋初始值，初始化完成。
-
-
第三步 局部变量引用和初始化后的对象建立关联。
-
7、对象的创建过程中，如果第二步和第三步指令执行顺序发生互换，会导致this对象的逸出问题，看看以下小程序，age输入的值是什么？
package com.yang.bootmongo.entity;
import java.io.IOException;
public class User {
private int age = 8;
//构造方法中启动了一个线程读取age
public User(){
new Thread(()->
System.out.println(this.age)
).start();
}
public static void main(String[] args) throws IOException {
User user = new User();
//为了保证主线程执行完之前子线程先执行完，此处设置主线程阻塞住不结束
System.in.read();
}
}
输出的值大概率是8，小概率是0，上面降到了对象创建的过程中先经过半初始化状态（开辟内存，引用即this的成员变量赋默认值）后，如果第二步和第三步调换了顺序即引用与半初始化对象先建立了关联，然后调用构造方法初始化,构造方法执行的过程中，可能还没有执行完，子线程就去读取age的值，此时的age就是半初始化时的默认值。所以，所谓的this对象的逸出，指的就是对象没有完全初始化完成，处于中间状态就被拿来使用了（比如age = 0 就好比是中间状态对象的属性）。为了避免this逸出的问题，我们一般不要在构造方法中启动线程，你可以在构造方法中创建线程，但是不要在构造方法中启动，可以单独写个启动线程的方法或者以你喜欢的方式来启动，以下程序是对上一个程序的改造
package com.yang.bootmongo.entity;
import java.io.IOException;
public class User {
private int age = 8;
static Thread t1
//构造方法中启动了一个线程读取age
public User(){
t1 = new Thread(() ->
System.out.println(this.age)
);
}
public static void main(String[] args) throws IOException {
User user = new User();
t1.start();
//为了保证主线程执行完之前子线程先执行完，此处设置主线程阻塞住不结束
System.in.read();
}
}
8.DCL（Double Check Lock）双重检查+锁（以懒汉式单例模式为例），代码及分析如下
package com.yang.Threads;
/**
* @Author: Gy
* @Description: DCL单例模式 懒汉式
* @Date
* @Modified By:
*/
public class TestSingleton {
private static volatile Object object;
private TestSingleton(Object object){
}
public static Object newInstance(){
if(null == object){ //**A**
synchronized (TestSingleton.class){ //**B**
if (null == object){ //**C**
object = new Object();
}
}
}
return object;
}
public static void main(String[] args) {
System.out.println(object);
Object o1 = TestSingleton.newInstance();
Object o2 = TestSingleton.newInstance();
System.out.println(o1 == o2);
}
}
分析：比如当前有10线程(t1,t2…t10)几乎同时来获取单例对象实例，在执行到A处时，有8个线程不满足判断条件，那么此时，只剩下两个（这里叫t1和t2）线程执行到B处，只有这两个线程参与锁的竞争，我们知道多个线程同时参与锁的竞争是一件非常消耗资源的事情，所以A处判断可以节省资源提高效率，避免了8个线程不必要的锁竞争。接着开始的思路，只有两个线程(t1和t2)参与了锁竞争，假设t1先争抢到锁资源，先执行到C处，满足条件，直到执行结束释放锁（此时已经实例化了一个object对象出来），此时等待着的t2得到锁资源开始执行，执行到C处，判断不成立，直接使用已经存在的object对象。假如没有C处的代码，t1和t2各自会创建一个对象出来，会出现不是一个对象的情况。然后使用volatile修改object引用，是为了避免对象创建过程中的指令重排序的问题，避免拿到半初始化的对象来使用。
594
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
