局部变量与成员变量的线程安全分析

￡神魔★判官ぃ 2022-11-17 03:38 221阅读 0赞

### 局部变量与成员变量的线程安全分析 ###

#### 前言 ####

观看[黑马程序员全面深入学习java并发编程][java]遇到了疑问，进行总结，同时发现了一篇文章写的也不错，是根据视频进行的总结。[https://blog.csdn.net/m0\_37989980/article/details/111400237][https_blog.csdn.net_m0_37989980_article_details_111400237]

#### 线程安全分析 ####

**成员变量和静态变量是否线程安全？**

*  如果它们没有共享，则线程安全
 *  如果它们被共享了，根据它们的状态是否能够改变，又分两种情况
    
     *  如果只有读操作，则线程安全
     *  如果有读写操作，则这段代码是临界区，需要考虑线程安全

**局部变量是否线程安全？**

*  局部变量是线程安全的
 *  但局部变量引用的对象则未必
    
     *  如果该对象没有逃离方法的作用访问，它是线程安全的
     *  如果该对象逃离方法的作用范围，需要考虑线程安全

#### 成员变量示例 ####

static final int THREAD_NUMBER = 2;
        static final int LOOP_NUMBER = 200;
        public static void main(String[] args) { 
            ThreadUnsafe test = new ThreadUnsafe();
            for (int i = 0; i < THREAD_NUMBER; i++) { 
                new Thread(() -> { 
                    test.method1(LOOP_NUMBER);
                }, "Thread" + i).start();
            }
        }
    
    class ThreadUnsafe { 
        ArrayList<String> list = new ArrayList<>();
        public void method1(int loopNumber) { 
            for (int i = 0; i < loopNumber; i++) { 
                // { 临界区, 会产生竞态条件
                method2();
                method3();
                // } 临界区
            }
        }
        private void method2() { 
            list.add("1");
        }
        private void method3() { 
            list.remove(0);
        }
    }

**报错分析**

**因为list是成员变量，无论哪个线程中的 method2 引用的都是同一个堆中的 list 成员变量**

**此时list存在并发问题，因为多个Thread使用的同一个list，在并发情况下add操作可能被覆盖，导致remove的比add的多从而报错**

![image-20210408085806689][]

#### **局部变量示例** ####

class ThreadSafe { 
        public final void method1(int loopNumber) { 
            ArrayList<String> list = new ArrayList<>();
            for (int i = 0; i < loopNumber; i++) { 
                method2(list);
                method3(list);
            }
        }
        private void method2(ArrayList<String> list) { 
            list.add("1");
        }
        private void method3(ArrayList<String> list) { 
            list.remove(0);
        }
    }

**分析**

list 是局部变量，每个线程调用时会创建其不同实例，没有共享，所以list不存在并发问题

而 method2 的参数是从 method1 中传递过来的，与 method1 中引用同一个对象  
![image-20210408090418156][]

#### **继承父类线程不安全示例** ####

对上方代码的method3进行重写后，出现线程不安全

class ThreadSafeSubClass extends ThreadSafe{ 
        @Override
        public void method3(ArrayList<String> list) { 
            new Thread(() -> { 
                list.remove(0);
            }).start();
        }
    }

**报错分析**

对父类的method3进行重写后，method3新开线程操作list，所以每个thread中method1线程和method2是主线程，到了method3新开线程，method2和method3是不同的线程共享list，存在线程安全问题

**然而list是局部变量，每个method1的thread不共享list，为什么还会不安全？**

本来猜测是不是多线程并发导致的list的add出现覆盖问题，但是局部变量的list是线程私有，不该有问题，于是我把主函数就设了一个线程，加大了method1中循环次数，发现仍然有问题，错误锁定在了method2和method3的执行顺序问题

因为在method1中的for循环，由于method3新开了线程，所以这里method2和method3没有防止指令重排，执行顺序会出问题。

在上一个局部变量示例中，没对method3进行重写，我对线程进行了输出，1，0交错打印

public void method2(ArrayList<String> list) { 
            System.out.println((Thread.currentThread() + "1"));
        }
        public void method3(ArrayList<String> list) { 
            System.out.println((Thread.currentThread() + "0"));
        }

![image-20210408091447937][]

在重写之后，我发现for循环并不是按顺序执行的，可能method3会在method2之前执行，这就导致了remove发生错误

**这里我猜测是因为原本的局部变量示例method2和method3是在同一个线程中，需根据*as*\-*if*\-*serial*语义，进行了指令重排，保证method3在method2之后执行**

**而重写method3之后，method2和method3在不同线程，所以可能导致method3被指令重排到之前执行，出现问题**

public void method3(ArrayList<String> list) { 
            new Thread(() -> { 
                System.out.println((Thread.currentThread() + "0"));
            }).start();
        }

\[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-yUXLLMGS-1617846620121)(https://i.loli.net/2021/04/08/1SQpaOPHfRNrG58.png)\]

![image-20210408091838411][]  
![image-20210408091527102][]

#### 完整代码 ####

package com.apollo.day02;
    
    import java.util.ArrayList;
    
    public class demo1 { 
        public static void main(String[] args) { 
            ThreadSafeSubClass test = new ThreadSafeSubClass();
            for(int i = 0 ; i < 1; i++){ 
                new Thread(()->{ 
                    test.method1(20000);
                }, "Thread" + (i + 1)).start();
            }
        }
    
    }
    class ThreadSafe { 
        public void method1(int loopNumber) { 
            ArrayList<String> list = new ArrayList<>();
            for (int i = 0; i < loopNumber; i++) { 
                method2(list);
                method3(list);
            }
        }
        public void method2(ArrayList<String> list) { 
    // list.add("1");
            System.out.println((Thread.currentThread() + "1"));
        }
        public void method3(ArrayList<String> list) { 
    // list.remove(0);
            System.out.println((Thread.currentThread() + "0"));
        }
    }
    
    class ThreadSafeSubClass extends ThreadSafe{ 
        @Override
        public void method3(ArrayList<String> list) { 
            new Thread(() -> { 
    // list.remove(0);
                System.out.println((Thread.currentThread() + "0"));
            }).start();
        }
    }

#### final和private的必要性 ####

**根据上一个例子，我们可以用final禁止类被继承，防止子类重写方法搞事情，也可以直接把方法设为private禁止重写。**

方法访问修饰符带来的思考: 如果把上述例子2中的method2和method3 的方法修改为public 会不会导致线程安全问题;

分情况:  
**情况1：有其它线程调用 method2 和 method3**  
只修改为public修饰,此时不会出现线程安全的问题, 即使线程2调用method2/3方法, 给2/3方法传过来的list对象也是线程2调用method1方法时,传递给method2/3的list对象, 不可能是线程1调用method1方法传的对象。

**情况2：在情况1 的基础上，为ThreadSafe 类添加子类**，子类覆盖method2 或 method3方法，即如下所示： 从这个例子可以看出 private 或 final 提供【安全】的意义所在，请体会开闭原则中的【闭】

> 如果改为public, 此时子类可以重写父类的方法, 在子类中开线程来操作list对象, 此时就会出现线程安全问题:  
> 子类和父类共享了list对象 如果改为private, 子类就不能重写父类的私有方法, 也就不会出现线程安全问题;  
> 所以所private修饰符是可以避免线程安全问题. 所以如果不想子类, 重写父类的方法的时候, 我们可以将父类中的方法设置为private,  
> final修饰的方法, 此时子类就无法影响父类中的方法了!

[java]: https://www.bilibili.com/video/BV16J411h7Rd?p=65
[https_blog.csdn.net_m0_37989980_article_details_111400237]: https://blog.csdn.net/m0_37989980/article/details/111400237
[image-20210408085806689]: /images/20221022/b1b30ba796584338b94c022e33022745.png
[image-20210408090418156]: /images/20221022/bb4075ebd6ff41ed8a977e1faff49195.png
[image-20210408091447937]: /images/20221022/e69ec815071d41f3a807097075e098d1.png
[image-20210408091838411]: /images/20221022/57cb15ab31d64f8aa20a4d3643eeeccc.png
[image-20210408091527102]: /images/20221022/9e06c9d771e443828b802617d76857ac.png

发表评论取消回复

表情：

评论列表（有 0 条评论，221人围观）

还没有评论，来说两句吧...

相关阅读

相关 Java成员变量与局部变量

堆、栈、方法区 **堆（Heap）** 此内存区域的唯一目的就是存放对象实例，几乎所有的对象实例都在这里分配内存，即所有的对象实例以及数组都要在堆上分配。 **栈...

以你之姓@/ 2024年04月17日 21:59/ 0 赞/ 104 阅读

相关成员变量与局部变量

成员变量与局部变量成员变量：在类体中定义的变量为成员变量，作用范围（scope）是整个类，只要在这个类中都可以访问到它。局部变量：在一个方法或方法中的代码块（code

╰半夏微凉°/ 2024年02月17日 17:47/ 0 赞/ 41 阅读

相关局部变量与成员变量的区别

文章目录局部变量与成员变量的区别分析小测试看题请说出打印结果如果对此有疑惑那么请看下去 public c

喜欢ヅ旅行/ 2022年12月22日 11:27/ 0 赞/ 210 阅读

相关局部变量与成员变量的线程安全分析

局部变量与成员变量的线程安全分析前言观看[黑马程序员全面深入学习java并发编程][java]遇到了疑问，进行总结，同时发现了一篇文章写的也不错，是根据视频进行

￡神魔★判官ぃ/ 2022年11月17日 03:38/ 0 赞/ 222 阅读

相关 Java基础_6--成员变量与局部变量

根据定义变量位置的不同，可以将变量分为成员变量和局部变量成员变量是在类范围内定义的变量局部变量是在一个方法内定义的变量成员变量(存在于堆内存中，

梦里梦外;/ 2022年09月06日 14:21/ 0 赞/ 229 阅读

相关多线程启动时，局部变量与成员变量的差异

<pre name="code" class="java">public class ThreadTest3 { public static voi

我就是我/ 2022年08月27日 12:58/ 0 赞/ 144 阅读

相关成员变量vs局部变量

相同点：遵循变量声明的格式有一定的作用域、都有初始化值不同点： <table> <tbody> <tr> <td> <p style="co

ゝ一世哀愁。/ 2022年08月21日 12:50/ 0 赞/ 245 阅读

相关 JavaSE 成员变量与局部变量

![这里写图片描述][SouthEast] -------------------- 成员变量和实例变量，类变量的区别 A:在类中的位置不同成员变量：在类中方法

系统管理员/ 2022年06月14日 07:44/ 0 赞/ 263 阅读

相关局部变量与成员变量

成员变量: 定义在类中变量局部变量: 定义在方法中变量成员变量与局部变量的区别： 1. 应用范围 1. 成员变量在整个类内都有效 2. 局部变量只在其声明的方法内

忘是亡心i/ 2022年05月22日 01:51/ 0 赞/ 272 阅读

相关从内存分析局部变量与成员变量的区别(Java)

目录前言一、考点二、分析 1、局部变量与成员变量的区别 2、代码分析后记 -------------------- 前言首先，咱们来看一道

系统管理员/ 2021年09月20日 21:38/ 0 赞/ 342 阅读