引出

Java多线程——synchronized、volatile 保障可见性

---

synchronized、volatile 保障可见性

• 原子性：在一次或者多次操作时，要么所有操作都被执行，要么所有操作都不执行。
• 可见性：当一个线程对共享变量进行修改后，另外一个线程可以立即看到该变量修改后的最新值。
• 有序性：程序执行的顺序按照代码的先后顺序执行。

synchronized关键字和Lock相关的工具类可以保证原子性、可见性和有序性，volatile关键字可以保证可见性和有序性，不能保证原子性。

可见性：synchronize、volatile

原子性：synchronize

volatile保证数据的可见性，但是不保证原子性(多线程进行写操作，不保证线程安全);而synchronized是一种排他（互斥）的机制。

主线程无法感知t1线程修改了flag值：

private static Boolean flag = false;
public static void main(String[] args) throws Exception {
    Thread t1 = new Thread(()->{
        try {
            Thread.sleep(2000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        flag = true;
    });
    t1.start();
    while (true) {
        if (flag) {
            System.out.println("线程修改了flag");
            break;
        }
    }
}

解决1：synchronized。 程序执行synchronized后，会清空工作内存副本数据，之后就从新从主内存获取数据

while (true) {
    synchronized (flag) { 
        if (flag) {
            System.out.println("线程修改了flag");
            break;
        }
    }
}

某一个线程进入synchronized代码块前后，执行过程入如下：
线程获得锁
清空工作内存
从主内存拷贝共享变量最新的值到工作内存成为副本
执行代码
将修改后的副本的值刷新回主内存中
线程释放锁

解决2：volatile 也可以保证多线程之间访问共享变量时的可见性。

public class App10 {
    private static volatile Boolean flag = false;
    public static void main(String[] args) throws Exception {
        Thread t1 = new Thread(() -> {
            try {
                Thread.sleep(2000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            flag = true;
        });
        t1.start();
        while (true) {
            if (flag) {
                System.out.println("线程修改了flag");
                break;
            }
        }
    }
}

子线程t从主内存读取到数据放入其对应的工作内存
将flag的值更改为true，但是这个时候flag的值还没有写会主内存
此时main方法main方法读取到了flag的值为false
当子线程t将flag的值写回去后，失效其他线程对此变量副本
再次对flag进行操作的时候线程会从主内存读取最新的值，放入到工作内存中

总结： volatile保证不同线程对共享变量操作的可见性，也就是说一个线程修改了volatile修饰的变量，当修改写回主内存时，另外一个线程立即看到最新的值。

Redis冲冲冲——缓存三兄弟：缓存击穿、穿透、雪崩

缓存击穿

缓存击穿：redis中没有，但是数据库有

顺序：先查缓存，判断缓存是否存在；如果缓存存在，直接返回数据；如果缓存不存在，則查询数据库，将数据库的数据存入到缓存

解决方案：将热点数据设置过期时间长一点；针对数据库的热点访问方法上分布式锁；

缓存穿透

缓存穿透：redis中没有，数据库也没有

解决方案：

（1）将不存在的key，在redis设置值为null；

（2）使用布隆过滤器;

原理：https://zhuanlan.zhihu.com/p/616911933

布隆过滤器：

如果确认key不存在于redis中，那么就一定不存在；

它说key存在，就有可能存在，也可能不存在！ （误差）

布隆过滤器

1、根据配置类中的 key的数量 ，误差率，计算位图数组【二维数组】

2、通过布隆过滤器存放key的时候，会计算出需要多少个hash函数，由hash函数算出多少个位图位置需要设定为1

3、查询时，根据对应的hash函数，判断对应的位置值是否都为1；如果有位置为0，则表示key一定不存在于该redis服务器中；如果全部位置都为1，则表示key可能存在于redis服务器中；

缓存雪崩

缓存雪崩：

Redis的缓存雪崩是指当Redis中大量缓存数据同时失效或者被清空时，大量的请求会直接打到数据库上，导致数据库瞬时压力过大，甚至宕机的情况。

造成缓存雪崩的原因主要有两个：

1.相同的过期时间：当Redis中大量的缓存数据设置相同的过期时间时，这些数据很可能会在同一时间点同时失效，导致大量请求直接打到数据库上。

2.缓存集中失效：当服务器重启、网络故障等因素导致Redis服务不可用，且缓存数据没有自动进行容错处理，当服务恢复时大量的数据同时被重新加载到缓存中，也会导致大量请求直接打到数据库上。

预防缓存雪崩的方法主要有以下几种：

1.设置不同的过期时间：可以将缓存数据的过期时间分散开，避免大量缓存数据在同一时间点失效。

2.使用加锁：可以将所有请求都先进行加锁操作，当某个请求去查询数据库时，如果还没有加载到缓存中，则只让单个线程去执行加载操作，其他线程等待该线程完成后再次进行判断，避免瞬间都去访问数据库从而引起雪崩。

3.提前加载预热：在系统低峰期，可以提前将部分热点数据加载到缓存中，这样可以避免在高峰期缓存数据失效时全部打到数据库上。

4.使用多级缓存：可以在Redis缓存之上再使用一层缓存，例如本地缓存等，当Redis缓存失效时，还能够从本地缓存中获取数据，避免直接打到数据库上。

本地缓存：ehcache oscache spring自带缓存 持久层框架的缓存

---

总结

Java多线程——synchronized、volatile 保障可见性