【多线程】多线程（4）（线程安全问题的原因，如何解决线程安全问题）-CSDN博客

本文链接：https://blog.csdn.net/2301_81305165/article/details/142514136

【线程安全问题的原因（重点掌握）】

1.线程在操作系统中:随机调度，抢占式执行（核心原因）

2.多个线程同时修改一个变量

3.修改操作「不是原子的」

4.内存可见性

5.指令重排列

（后两个原因后面再谈）

对于多线程（3）末尾两个线程对count++的修改操作来说，它「不是原子的」，不是原子的修改操作会产生线程安全问题

“原子”是不可分割的最小单位

站在cpu的视角上，「一条指令」就是cpu不可分割的最小单位，因此它在进行调度切换线程时，势必会确保:执行完这条指令再进行调度切换

因此前文中“count++”这种操作就「不是原子的」，因为它背后包含了三个指令

【如何解决线程安全问题】

最主要的办法，就是把「非原子的代码」打包成「原子的代码」，也被称为「加锁」

通过这种加锁的方式，放在前文count++的代码中，就可以令一个线程在执行count++的过程中，其他线程不能count++进来

【synchronized使用方式一:圆括号指定锁对象】

synchronized是完成“加锁”操作的关键字

「synchronized」是一个关键字，不是函数，后面的“（）”并非是参数，里面需要指定一个“锁对象”，来表示对谁加锁，后面的大括号中存放的就是要打包成原子操作的代码

 public static int count = 0;
    public static Object locker = new Object();

    public static void main(String[] args) throws InterruptedException {
        Thread t1 = new Thread(() ->{
            for(int i = 0;i < 50000;i++){
                synchronized (locker) {
                    count++;
                }
            }
        });
        Thread t2 = new Thread(() ->{
            for(int i = 0;i < 50000;i++){
                synchronized (locker) {
                    count++;
                }
            }
        });

        t1.start();
        t2.start();
        t2.join();
        t2.join();
        System.out.println("count=" + count);

锁对象可以通过如图所示，通过Object类来创建，在synchronized的（）中就可以存放这个锁对象

在进入代码块时，就会针对锁对象加锁

在出了代码块时（包括return，抛出异常），针对锁对象解锁

synchronized的{}中还可以放任意的其他代码，包括调用其他方法之类，只要是合法的代码皆可以

因此，在该代码中，由于t1和t2都是针对locker进行加锁，t1先加锁，因此t1加锁成功，并执行锁内部的代码，t2后加锁，发现locker对象被t1已经使用了，因此t2加锁失败，进入阻塞，一直阻塞到t1释放锁为止

【加锁的有效性】

上述代码有效的前提是，两个线程都加锁，且都加同一把锁

若有线程不“加锁”：

若针对不同的对象“加锁”：

锁对象，就是用来区分两个/多个线程是否针对“同一个对象”加锁

若是，则会出现「阻塞」（锁竞争/锁冲突），若不是，则不会出现阻塞，两个线程仍然是随机调度的并发执行

因此，锁对象，填哪个对象不重要，重要的是，多个线程是否针对同一个锁对象

【锁对象的类型】

锁对象，必须是一个对象

不能用int，double这种内置类型来写，锁对象的类型必须是Object类或它的子类

也就是说，用String，List＜＞这种类型构建锁对象是完全可以的

此外，若是多个线程（两个以上）针对同一个锁对象加锁，拿到锁的对象释放了锁后，剩下的线程谁先拿到锁？这是随机的

【synchronized使用方法二：修饰一个静态的方法】

相当于针对“对应的类对象”加锁（这里设该代码在Counter类中）

这个「文件名.class」的写法就是「类对象」

一个Java进程中，一个类的类对象是只有一个的，类对象也是对象，所以也能写到synchronized中，写类对象和写其他对象没有任何本质区别

换句话说，写成类对象就是“偷懒”的做法，不想创建单独的锁对象，就可以用类对象来客串一下

【synchronized使用方法三：修饰一个普通的方法】

相当于针对this加锁

public class Demo3 {
    public static int count = 0;
    synchronized public void add() {
        count++;
    }

    public static void main(String[] args) throws InterruptedException {
        Demo3 demo3 = new Demo3();//创建类对象的实例
        Thread t1 = new Thread(() ->{
            for(int i = 0;i < 50000;i++){
               demo3.add();
            }
        });
        Thread t2 = new Thread(() ->{
            for(int i = 0;i < 50000;i++){
                demo3.add();
            }
        });

        t1.start();
        t2.start();
        t2.join();
        t2.join();
        System.out.println("count=" + count);


    }
}

调用方法时并没有直接写synchronized，但方法本身带有synchronized，这样的方法也是可以起到加锁的效果

synchronized需要明确锁对象，针对于这个写法，锁对象就是“this”