1.线程安全问题举例

看代码:

class Count {
    int i = 0;
    public void add(){
        i++;
    }
}
public class Test1 {
    public static void main(String[] args) throws InterruptedException {
        Count count = new Count();
        
        //创建一个线程,使i自加1w次
        Thread thread1 = new Thread(() ->{
            for (int i = 0; i < 10000; i++) {
                count.add();
            }
        });

        //再次创建一个线程,使i自加1w次
        Thread thread2 = new Thread(() -> {
            for (int i = 0; i < 10000; i++) {
                count.add();

            }
        });
        
        thread1.start();
        thread2.start();
        thread1.join();
        thread2.join();
        
        System.out.println(count.i);//打印i自加2w次之后的结果

    }
}

结果:
在这里插入图片描述

i自加2w次之后应该是2w,可是第一次打印的结果是18971,第二次打印的结果是19478,与我们想象的2w有一定的差距,上面这种情况就叫是典型的线程安全问题.

为什么会出现这种情况?
在这里插入图片描述

还有无数种情况就不一一列举了;其中只有第一次情况是正确的

由于线程的抢占式执行,导致当前线程执行到任意一个指令的时候,都有可能被调度走,CPU让别的线程来执行;
CPU里有个重要的组成部分,寄存器.寄存器也能存数据.空间更小,访问速度更快.CPU进行的运算都是针对寄存器中的数据进行的.

在这里插入图片描述

2.为什么会有线程安全问题

因为线程的抢占式执行模式,导致代码执行的顺序会有很多变数,代码的执行顺序就从一种情况变成了无数种情况,所以就需要保证在这种有无数种想成调度顺序的情况下,代码执行结果是正确的
问题一: 能否消除线程执行顺序的随机性?
不能!

出现线程安全问题的原因:
在这里插入图片描述
这五个只是典型的线程安全问题的原因,并不是全部原因

3.如何解决线程安全问题

1.从原子性入手解决线程安全问题

关键字:synchronized

class Count {
    int i = 0;
    synchronized public void add(){
        i++;
    }
}

当我们给上面的方法加上synchronized之后,进入方法就加锁,出了方法就会解锁,如果两个线程同时尝试加锁,那么只有一个线程可以成功,另外一个线程只能阻塞等待(BLOCKED),直到刚才加锁成功的线程解锁,当前阻塞等待的线程才能加锁成功!!!
在这里插入图片描述

2.synchronized的使用方法

在这里插入图片描述
注意:

一个线程可以给两个对象加锁
线程是对对象加锁,虽然synchronized是修饰在方法上的

在这里插入图片描述
注意：synchronized是可重入的，因为对于同一个锁对像（this）第一次进入的时候对他加锁了，第二次再进入的时候，就会发现已经上过锁了，此时是不会进入线程阻塞的，因为第一个线程和第二个线程是同一个线程

3.java标准库中的线程安全类

在这里插入图片描述

4.死锁问题

举例

为什么会有死锁问题？
1.一个线程一把锁，连续加锁两次，如果锁是可重入锁，就没有问题（java中的synchronized和ReentrantLock就是可重入锁），如果所示不可重入锁，就会出现死锁问题；
在这里插入图片描述
2.两个线程两把锁，t1和t2都各自针对锁A和锁B加锁，接着又尝试获取对方的锁

class B{

}
public class Test3 {
    public static void main(String[] args) throws InterruptedException {
        B chifan = new B();
        B heshui = new B();
        Thread t1 = new Thread(() -> {
           synchronized (chifan){ 
               System.out.println("小明 -> 吃饭");
               synchronized (heshui){
                   System.out.println("小明 -> 吃饭、喝水");
               }
           }

        });
        Thread t2 = new Thread(() -> {
           synchronized (heshui){
               System.out.println("小红 -> 喝水");
               synchronized (chifan){
                   System.out.println("小红 -> 喝水、吃饭");
               }
           }

        });
        t1.start();

        t2.start();
    }

}