1. 前言

Java多线程环境下，多个线程同时访问共享资源时可能出现的数据竞争和不一致的情况。

线程安全一直都是一个令人头疼的问题.为了解决这个问题,Java为我们提供了很多方式.

synchronized关键字、ReentrantLock类等。
使用线程安全的数据结构，例如ConcurrentHashMap、ConcurrentLinkedQueue等，避免共享资源
使用volatile关键字保证内存可见性等方法。

本文主要介绍synchronized关键字
在这里插入图片描述

2. 线程安全问题演示

多线程环境下可能会产生的问题
先看下面这个Test类:

class Test{
    private int count = 0;
    public void add(){
        count++;
    }

    public int getCount() {
        return count;
    }
}

count是一个普通的成员变量,提供了一个add()方法,让count进行自增
同时提供了一个get方法获取到count的值.

再来看下面这段代码:

public class Demo8 {
    private static Test test = new Test();
    public static void main(String[] args) throws InterruptedException {
        Thread t1 = new Thread(() -> {
            for (int i = 0; i < 50000; i++) {
                test.add();
            }
        });
        Thread t2 = new Thread(() -> {
            for (int i = 0; i < 50000; i++) {
                test.add();
            }
        });
        t1.start();
        t2.start();

        t1.join();
        t2.join();
        System.out.println(test.getCount());
    }
}

创建了一个Test类的实例,同时创建两个线程.
让这两个线程各调用50000次Test实例的add()方法,最后输出count的值.

按理来说应该是count的值应该是100000.

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

可以看到运行结果不是100000,而是比100000小. 而且两次运行的结果还不一样.
这就是一个典型的线程安全问题

3.线程安全问题的原因

上述问题产生的原因:
这里的原因主要是 count++操作,count++是三条指令在CPU上执行的.
count++可以分为3个步骤:
在这里插入图片描述

由于当前是两个线程同时修改同一份变量
且修改操作不是原子的
加上线程之间调度的不确定性

上述三条原因导致了这两个线程执行count++操作时,执行的顺序会有多种情况.
例如:
在这里插入图片描述
ps: 这只是其中的一种情况

如果是这种情况会导致什么呢?

看这张图:
在这里插入图片描述
t2线程已经修改过count的值了,但是由于t1并没有获取到count最新的值,因此t1只是在原来读到的count值得基础上进行修改.

因此虽然是执行了两次count++操作,但是真正执行完的效果只有一次count++.这也就是为什么count的值小于100000的原因了.

如果想要让执行完的结果为100000,那么就需要使用synchronized关键字进行加锁了

4.synchronized关键字

synchronized关键字是用于实现线程同步的机制，可以保证在同一时刻只有一个线程可以访问被synchronized包围的代码块或方法，从而避免了多个线程同时访问共享资源时可能出现的数据竞争和不一致的情况。

以上是一些synchronized关键字的介绍,相比大家也不喜欢看这些定义.

接下来就以我自己的方式为大家讲解:

上述问题的解决:
使用synchronized对count++操作进行加锁,count++之后再进行解锁

此时一个线程在count++时进行加锁后,另外一个线程想进行修改,是修改不了的.这个线程只能阻塞等待

上面提到了使用synchronized进行加锁,什么是加锁呢?
例如下面这张图:
在这里插入图片描述
之前疫情期间,相比大家核酸都没少做吧.
做核酸一次只能给一个人做,如有当前已经有人在做核酸了,那么下一个人只能等待.只有等前面那个人做完,才能够去做.

这里的做核酸就相当于 count++, 去做核酸就相当于是加锁, 在有人做核酸时,其它人只能等待(阻塞等待).做完离开,就相当于解锁(释放锁)

那么如果使用synchronized进行加锁解决上面的问题呢? .

可以对add方法进行加锁.
在这里插入图片描述
执行add方法时会加锁,执行完add方法会解锁.

修改之后的运行结果就是100000了.
在这里插入图片描述

synchronized关键字可以应用于方法(上述示例)和代码块两种情况：

修饰方法：将synchronized关键字放在方法声明前，表示该方法是同步方法，只有一个线程可以访问该方法。例如：

public synchronized void method() {
    // 同步代码块
}

修饰代码块：将synchronized关键字放在代码块前，表示该代码块是同步代码块，只有一个线程可以执行该代码块。例如：

public void method() {
    synchronized (锁对象) {
        // 同步代码块
    }
}

在Java中任何对象都可以作为"锁对象".这里的锁对象十分关键

两个(多个)线程针对同一个对象进行加锁,才会有锁竞争. 如果不对同一个对象进行加锁,每个线程各执行各的,就不会产生锁竞争.也就不会阻塞等待.

因此使用synchronized的加锁的时候,要考虑清楚对哪段代码进行加锁,锁的代码不同,对执行的效果会有很大的影响.

锁的代码越多,锁的粒度越大/越粗,所得代码越少,锁的粒度越小/越细

synchronized关键字的使用需要注意以下几点：

synchronized关键字只能保证同一个对象的同步代码块或同步方法是互斥的，不同对象的同步代码块或同步方法是不互斥的。
synchronized关键字的使用会降低程序的执行效率，因为它会导致线程的上下文切换和锁的竞争。
synchronized关键字只能保证互斥的访问，不能保证线程安全，需要结合其他机制来保证线程安全，例如使用volatile关键字、Atomic类、Lock接口等。