heima并发9---第五章--134-157

jmm模型。

JMM内存模型解决的是原子性有序性和可见性。

---05-- 001--

代码：

这个太经典了

package cn.itcast.test;

import lombok.extern.slf4j.Slf4j;

import static cn.itcast.n2.util.Sleeper.sleep;

@Slf4j(topic = "c.Test32")
public class Test32 {
    // 易变
    volatile static boolean run = true;

    public static void main(String[] args) throws InterruptedException {
        Thread t = new Thread(()->{
            while(true){
                    if(!run) {
                        break;
                    }
            }
            log.debug("停止");
        });
        t.start();

        sleep(1);
            run = false; // 线程t不会如预想的停下来
    }
}

---05--002-

改进volatile或者synchronized：

用synchronized也可以的。

---05-  03 --

volatile主要解决可见性的问题，适合只有一个线程写多个线程读的情况。

---05  4  ---

---

老的代码:

两阶段中止，新的：

---05-   005 --

package cn.itcast.test;

import lombok.extern.slf4j.Slf4j;

@Slf4j(topic = "c.TwoPhaseTermination")
public class Test13 {
    public static void main(String[] args) throws InterruptedException {
        TwoPhaseTermination tpt = new TwoPhaseTermination();
        tpt.start();
        Integer a = 1;
        Thread.sleep(3500);
        log.debug("停止监控");
        tpt.stop();
    }
}

@Slf4j(topic = "c.TwoPhaseTermination")
class TwoPhaseTermination {
    // 监控线程
    private Thread monitorThread;
    // 停止标记
    private volatile boolean stop = false;
    // 判断是否执行过 start 方法
    private boolean starting = false;

    // 启动监控线程
    public void start() {
        synchronized (this) {
            if (starting) { // false
                return;
            }
            starting = true;
        }
        monitorThread = new Thread(() -> {
            while (true) {
                Thread current = Thread.currentThread();
                // 是否被打断
                if (stop) {
                    log.debug("料理后事");
                    break;
                }
                try {
                    Thread.sleep(1000);
                    log.debug("执行监控记录");
                } catch (InterruptedException e) {
                }
            }
        }, "monitor");
        monitorThread.start();
    }

    // 停止监控线程
    public void stop() {
        stop = true;
        // 这个是不让sleep了
        monitorThread.interrupt();
    }
}

这块sync保护是为了防止多线程进来的。只要一个线程监控。

---05-  6  --

犹豫模式的应用。

---05- 7 -没刷-

指令重排序是多个指令的不同部分一块执行。

---

java重排序依然有这个优化。

经典的指令重排序代码

 加ready防止之前的代码排到后面去。

加一个就行了 不用两个都加 

为什么num不加是因为保证volatile之前的都是新的了。

---05- 8 - 12---

volatile可以保证可见性和有序性。

注意写屏障和读屏障加在哪里。

读屏障：

---05 13---

读写屏障的有序性

volatile解决的是有序性和可见性但是不能解决的是原子性

---05- 14 --

单例问题，加双重检验锁。

这是不对的。

这个在sync外面无法保证有序的原子可见

---

分析

---

如何解决：问题的根源在于构造方法排序到赋值给引用的下面，保证赋值的时候构造方法已经运行完了。

读屏障是防止屏障后的跑到前面去，写是防止屏障前跑到后面去。

并发脑图：https://naotu.baidu.com/file/89fb28b05e3395800f9dc2d332d2b198?token=9b45e08e55281667

---05-15--18-- 其中16 17 18 没看-

---05-- 19 -

volatile适合一个线程写其它的线程读操作，或者双重校验锁。

这个最好不要访问多次。

---153---

1.序列化是一个对象反序列化是另一个对象了

---154---

枚举：

反编译。

1.枚举类默认实现序列化接口的

2.饿汉

---155---

---156-157---