本文是两章的笔记整理。
CPU缓存计算机中的所有运算操作都是由CPU完成的，CPU指令执行过程需要涉及数据读取和写入操作，但是CPU只能访问处于内存中的数据，而内存的速度和CPU的速度是远远不对等的，因此就出现了缓存模型，也就是在CPU和内存之间加入了缓存层。一般现代的CPU缓存层分为三级，分别叫L1缓存、L2缓存和L3缓存，简略图如下：
L1缓存：三级缓存中访问速度最快，但是容量最小，另外L1缓存还被划分成了数据缓存（L1d，data首字母）和指令缓存（L1i，instruction首字母）L2缓存：速度比L1慢，但是容量比L1大，在现代的多核CPU中，L2一般被单个核独占L3缓存：三级缓存中速度最慢，但是容量最大，现代CPU中也有L3是多核共享的设计，比如zen3架构的设计缓存的出现，是为了解决CPU直接访问内存效率低下的问题，CPU进行运算的时候，将需要的数据从主存复制一份到缓存中，因为缓存的访问速度快于内存，在计算的时候只需要读取缓存并将结果更新到缓存，运算结束再将结果刷新到主存，这样就大大提高了计算效率，整体交互图简略如下：
虽然缓存的出现，大大提高了吞吐能力，但是，也引入了一个新的问题，就是缓存不一致。比如，最简单的一个i++操作，需要将内存数据复制一份到缓存中，CPU读取缓存值并进行更新，先写入缓存，运算结束后再将缓存中新的刷新到内存，具体过程如下：
i到缓存中CPU读取缓存i中的值i进行加1操作这样的i++操作在单线程不会出现问题，但在多线程中，因为每个线程都有自己的工作内存（也叫本地内存，是线程自己的缓存），变量i在多个线程的本地内存中都存在一个副本，如果有两个线程执行i++操作：
i初始值为0i的值放入缓存中，此时i的值为0，线程B也同理，放入缓存中的值也是0i的值都是1i写入主内存，相当于i被两次赋值为1i的值为1这个就是典型的缓存不一致问题，主流的解决办法有：
这是一种悲观的实现方式，具体来说，就是通过处理器发出lock指令，锁住总线，总线收到指令后，会阻塞其他处理器的请求，直到�加盟拇砥魍瓿刹僮鳌Ｌ氐闶侵挥幸桓銮赖阶芟咚拇砥髟诵校钦庵址绞叫实拖拢坏┠掣龃砥骰袢〉剿渌砥髦荒茏枞却嵊跋於嗪舜砥鞯男阅堋�
图示如下：
缓存一致性协议中最出名的就是MESI协议，MESI保证了每一个缓存中使用的共享变量的副本都是一致的。大致思想是，CPU操作缓存中的数据时，如果发现该变量是一个共享变量，操作如下：
CPU将该变量的缓存行设置为无效状态（Invalid），其他CPU进行该变量的读取时需要到主存中再次获取具体来说，MESI中规定了缓存行使用4种状态标记：
M：Modified，被修改E：Exclusive，独享的S：Shared，共享的I：Invalid，无效的有关MESI详细的实现超出了本文的范围，想要详细了解可以参考此处或此处。
JMM看完了CPU缓存再来看一下JMM，也就是Java内存模型，指定了JVM如何与计算机的主存进行工作，同时也决定了一个线程对共享变量的写入何时对其他线程可见，JMM定义了线程和主内存之间的抽象关系，具体如下：
JMM内存模型一样也是一个抽象概念，其实并不存在，涵盖了缓存、寄存器、编译期优化以及硬件等简略图如下：
与MESI类似，如果一个线程修改了共享变量，刷新到主内存后，其他线程读取工作内存的时候发现缓存失效，会从主内存再次读取到工作内存中。
而下图表示了JVM与计算机硬件分配的关系：
文章都看了大半了还没到volatile？别急别急，先来看看并发编程中的三个重要特性，这对正确理解volatile有很大的帮助。
原子性就是在一次或多次操作中：
一个典型的例子就是两个人转账，比如A向B转账1000元，那么这包含两个基本的操作：
这两个操作，要么都成功，要么都失败，也就是不能出现A账户扣除1000但是B账户金额不变的情况，也不能出现A账户金额不变B账户增加1000的情况。
需要注意的是两个原子性操作结合在一起未必是原子性的，比如i++。本质上来说，i++涉及到了三个操作：
get ii+1set i这三个操作都是原子性的，但是组合在一起（i++）就不是原子性的。
另一个重要的特性是可见性，可见性是指，一个线程对共享变量进行了修改，那么另外的线程可以立即看到修改后的最新值。
一个简单的例子如下：
public class Main {
private int x = 0;
private static final int MAX = 100000;
public static void main(String[] args) throws InterruptedException {
Main m = new Main();
Thread thread0 = new Thread(()->{
while(m.x < MAX) {
++m.x;
}
});
Thread thread1 = new Thread(()->{
while(m.x < MAX){
}
System.out.println("finish");
});
thread1.start();
TimeUnit.MILLISECONDS.sleep(1);
thread0.start();
}
}线程thread1会一直运行，因为thread1把x读入工作内存后，会一直判断工作内存中的值，由于thread0改变的是thread0工作内存的值，并没有对thread1可见，因此永远也不会输出finish，使用jstack也可以看到结果：
有序性是指代码在执行过程中的先后顺序，由于JVM的优化，导致了代码的编写顺序未必是代码的运行顺序，比如下面的四条语句：
int x = 10;
int y = 0;
x++;
y = 20;有可能y=20在x++前执行，这就是指令重排序。一般来说，处理器为了提高程序的效率，可能会对输入的代码指令做一定的优化，不会严格按照编写顺序去执行代码，但可以保证最终运算结果是编码时的期望结果，当然，重排序也有一定的规则，需要严格遵守指令之间的数据依赖关系，并不是可以任意重排序，比如：
int x = 10;
int y = 0;
x++;
y = x+1;y=x+1就不能先优于x++执行。
在单线程下重排序不会导致预期值的改变，但在多线程下，如果有序性得不到保证，那么将可能出现很大的问题：
private boolean initialized = false;
private Context context;
public Context load(){
if(!initialized){
context = loadContext();
initialized = true;
}
return context;
}如果发生了重排序，initialized=true排序到了context=loadContext()的前面，假设两个线程A、B同时访问，且loadContext()需要一定耗时，那么：
true，再进行loadContext()操作true，会直接返回一个未加载完成的contextvolatile好了终于到了volatile了，前面说了这么多，目的就是为了能彻底理解和明白volatile。这部分分为四个小节：
volatile的语义synchronized区别先来介绍一下volatile的语义。
被volatile修饰的实例变量或者类变量具有两层语义：
先说结论：
volatile能保证可见性volatile能保证有序性volatile不能保证原子性下面分别进行介绍。
Java中保证可见性有如下方式：
volatile：当一个变量被volatile修饰时，对共享资源的读操作会直接在主内存中进行（准确来说也会读取到工作内存中，但是如果其他线程进行了修改就必须从主内存重新读取），写操作是先修改工作内存，但是修改结束后立即刷新到主内存中synchronized：synchronized一样能保证可见性，能够保证同一时刻只有一个线程获取到锁，然后执行同步方法，并且确保锁释放之前，变量的修改被刷新到主内存中Lock：Lock的lock方法能保证同一时刻只有一个线程能够获取到锁然后执行同步方法，并且确保锁释放之前能够将对变量的修改刷新到主内存中具体来说，可以看一下之前的例子：
public class Main {
private int x = 0;
private static final int MAX = 100000;
public static void main(String[] args) throws InterruptedException {
Main m = new Main();
Thread thread0 = new Thread(()->{
while(m.x < MAX) {
++m.x;
}
});
Thread thread1 = new Thread(()->{
while(m.x < MAX){
}
System.out.println("finish");
});
thread1.start();
TimeUnit.MILLISECONDS.sleep(1);
thread0.start();
}
}上面说过这段代码会不断运行，一直没有输出，就是因为修改后的x对线程thread1不可见，如果在x的定义中加上了volatile，就不会出现没有输出的情况了，因为此时对x的修改是线程thread1可见的。
JMM中允许编译期和处理器对指令进行重排序，在多线程的情况下有可能会出现问题，为此，Java同样提供了三种机制去保证有序性：
volatilesynchronizedLock另外，关于有序性不得不提的就是Happens-before原则。Happends-before原则说的就是如果两个操作的执行次序无法从该原则推导出来，那么就无法保证有序性，JVM或处理器可以任意重排序。这么做的目的是为了尽可能提高程序的并行度，具体规则如下：
unlock操作要先行发生于对同一个锁的lock操作volatile变量规则：对一个变量的写操作要早于对这个变量之后的读操作Thread对象的start()方法先行发生于对该线程的任何动作interrupt()方法肯定要优于捕获到中断信号，换句话说，如果收到了中断信号，那么在此之前必定调用了interrupt()finalize()之前对于volatile，会直接禁止对指令重排，但是对于volatile前后无依赖关系的指令可以随意重排，比如：
int x = 0;
int y = 1;
//private volatile int z;
z = 20;
x++;
y--;在z=20之前，先定义x或先定义y并没有要求，只需要在执行z=20的时候，可以保证x=0,y=1即可，同理，x++或y--具体先执行哪一个并没有要求，只需要保证两者执行在z=20之后即可。
在Java中，所有对基本数据类型变量的读取赋值操作都是原子性的，对引用类型的变量读取和赋值也是原子性的，但是：
i++JMM只保证基本读取和赋值的原子性操作，其他的均不保证，如果需要具备原子性，那么可以使用synchronized或Lock，或者JUC包下的原子操作类也就是说，volatile并不能保证原子性，例子如下：
public class Main {
private volatile int x = 0;
private static final CountDownLatch latch = new CountDownLatch(10);
public void inc() {
++x;
}
public static void main(String[] args) throws InterruptedException {
Main m = new Main();
IntStream.range(0, 10).forEach(i -> {
new Thread(() -> {
for (int j = 0; j < 1000; j++) {
m.inc();
}
latch.countDown();
}).start();
});
latch.await();
System.out.println(m.x);
}
}最后输出的x的值会少于10000，而且每次运行的结果也并不相同，至于原因，可以从两个线程A、B开始分析，图示如下：
0-t1：线程A将x读入工作内存，此时x=0t1-t2：线程A时间片完，CPU调度线程B，线程B将x读入工作内存，此时x=0t2-t3：线程B对工作内存中的x进行自增操作，并更新到工作内存中t3-t4：线程B时间片完，CPU调度线程A，同理线程A对工作内存中的x自增t4-t5：线程A将工作内存中的值写回主内存，此时主内存中的值为x=1t5以后：线程A时间片完，CPU调度线程B，线程B也将自己的工作内存写回主内存，再次将主内存中的x赋值为1也就是说，多线程操作的话，会出现两次自增但是实际上只进行一次数值修改的操作。想要x的值变为10000也很简单，加上synchronized即可：
new Thread(() -> {
synchronized (m) {
for (int j = 0; j < 1000; j++) {
m.inc();
}
}
latch.countDown();
}).start();前面已经知道，volatile可以保证有序性以及可见性，那么，具体是如何操作的呢？
答案就是一个lock;前缀，该前缀实际上相当于一个内存屏障，该内存屏障会为指令的执行提供如下几个保障：
一个典型的使用场景是利用开关进行线程的关闭操作，例子如下：
public class ThreadTest extends Thread{
private volatile boolean started = true;
@Override
public void run() {
while (started){
}
}
public void shutdown(){
this.started = false;
}
}如果布尔变量没有被volatile修饰，那么很可能新的布尔值刷新不到主内存中，导致线程不会结束。
synchronized的区别volatile只能用于修饰实例变量或者类变量，但是不能用于修饰方法、方法参数、局部变量等，另外可以修饰的变量为null。但synchronized不能用于对变量的修饰，只能修饰方法或语句块，而且monitor对象不能为nullvolatile无法保证原子性，但是synchronized可以保证volatile与synchronized都能保证可见性，但是synchronized是借助于JVM指令monitor enter/monitor exit保证的，在monitor exit的时候所有共享资源都被刷新到主内存中，而volatile是通过lock;机器指令实现的，迫使其他线程工作内存失效，需要到主内存加载volatile能够禁止JVM以及处理器对其进行重排序，而synchronized保证的有序性是通过程序串行化执行换来的，并且在synchronized代码块中的代码也会发生指令重排的情况volatile不会使线程陷入阻塞，但synchronized会
macromedia dreamweaver 8序列号 激活码： wpd800-50438-28032-39991 wpd800-599...
Do not use these html elements in html pages. Presentational elements shoul...
1、使用css精灵。 好处是将css中使用的小图片可以合并为一张大图片减少了对服务...
随着网络时代的发展与进步，我们的学习工作和生活早已离不开互联网，智能家居、...
Dreamweaver网页中的banner图片需要切换，我们可以添加按钮来切换图片，下面我们...
这是一款基于HTML5和JavaScript的进度条应用，这款进度条插件非常有特点，它在进...
还记得我在《2020 年 JavaScript 状态调研报告小结》中提到的 2020 年全球开发者...
windows 下默认的滚动条样式巨丑，项目中又有比较多地方会显示滚动条， 故回头翻...
dreamweaver软件： 点此下载 1、熟悉网页设计的网友就知道，调用STYLE的方法很多...
在开发中，如果遇到需要使用canvas同时绘制多张图片，但因为图片大小的不一样，...
