线程安全2

锁的可重入性

直观来看这个代码不能运行
为啥没有出现阻塞？
当前由于是同一个线程，此时的锁对象，就知道了第二次加锁的线程，就是持有锁的线程，第二次操作，就可以直接放行通过，不会出现阻塞

这个特性称为“可重入”

对于可重入锁来说：内部会持有两个信息
1.当前锁是哪个线程持有的
2.加锁次数的计时器
过程描述：
第一次加锁的时候计数器+1（初始情况为0，+1后变成了1，说明当前这个对象被该线程加锁一次）同时记录线程是谁，第二次加锁的时候，发现加锁线程和持有线程是一个线程，第二次应该能够加锁成功，判断当前加锁进程是否持有锁的线程，如果不是同一个线程，阻塞如果是同一个线程，就只是++计数器，即可没有其他操作，此处的计时器（源码是在JVM中，c++代码实现出来的）是关键。

死锁

1.一个线程，一把锁
如果锁是不可重入锁，并且一个线程对这把锁加锁两次就会出现死锁（钥匙锁屋里了·）

2.两个线程，两把锁
线程1获取到锁A
线程2获取到锁B
接下来，1尝试获取B，2尝试获取A，此时会出现死锁

public static void main(String[] args) {
        Object A = new Object();
        Object B = new Object();
        Thread t1 = new Thread(() -> {
            synchronized (A) {
                // sleep 一下, 是给 t2 时间, 让 t2 也能拿到 B
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                // 尝试获取 B, 并没有释放 A
                synchronized (B) {
                    System.out.println("t1 拿到了两把锁!");
                }
            }
        });

        Thread t2 = new Thread(() -> {
            synchronized (B) {
                // sleep 一下, 是给 t1 时间, 让 t1 能拿到 A
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                // 尝试获取 A, 并没有释放 B
                synchronized (A) {
                    System.out.println("t2 拿到了两把锁!");
                }
            }
        });
        t1.start();
        t2.start();
    }
}

3.N个线程M把锁


线程一执行到22行

线程二执行到37行

这些线程安全的类也不是绝对的线程安全，只是自带了锁

内存可见性引起的线程安全

public class Test3 {
    private  static int flag = 0;
    public static void main(String[] args) {
        Thread t1 = new Thread(()->{
            while(flag == 0){

            }
            System.out.println("循环结束");
        });
        Thread t2 = new Thread(()->{
            System.out.println("请输入flag的值：");
            Scanner scanner = new Scanner(System.in);
            flag = scanner.nextInt();

        });
        t1.start();
        t2.start();
    }
}

在这个代码中，预期通过t2线程输入的整数，只要输入的不是0，就可以是t1线程结束。
t2要等待用户输入，无论t1先启动还是t2先启动，在等待用户输入的过程中，t1必然循环了很多次了
但是当我们输入非0值，没有输出结果，
原因：内存可见性引起的线程安全，while(flag == 0）由两个指令组成，
1.load读取内存的flag的值到cpu寄存器中
2.拿着寄存器的值与0进行比较
t1线程反复进行1，2操作，由于频繁执行load和条件跳转，load的开销大，并且load的结果又没有变化，此时JVM产生了怀疑，于是JVM就对代码进行了优化，load就被优化掉了，相当于不再重复读内存，直接使用寄存器中之前缓存的值，以提高循环的执行速度，t2修改了内存，但是t1没有看到，就导致了内存可见性问题
为了解决代码优化问题，Java提供了volatile就可以使上述的优化被强制关闭

private volatile static int flag = 0;