JUC并发编程 -- 变量的线程安全问题(成员变量 & 静态变量 & 局部变量 & 开闭原则 & 理解JDK 中 String 类的实现)
Posted Z && Y
tags:
篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了JUC并发编程 -- 变量的线程安全问题(成员变量 & 静态变量 & 局部变量 & 开闭原则 & 理解JDK 中 String 类的实现)相关的知识,希望对你有一定的参考价值。
1. 变量的线程安全分析
1.1 成员变量和静态变量是否线程安全?
- 如果它们没有共享,则线程安全
- 如果它们被共享了,根据它们的状态是否能够改变,又分两种情况:
- 如果只有读操作,则线程安全
- 如果有读写操作,则这段代码是临界区,需要考虑线程安全
1.2 局部变量是否线程安全?
- 局部变量是线程安全的
- 但局部变量引用的对象则未必
- 如果该对象没有逃离方法的作用访问,它是线程安全的
- 如果该对象逃离方法的作用范围,需要考虑线程安全
1.3 局部变量线程安全分析
对于下面的代码:
public static void test1() {
int i = 10;
i++;
}
每个线程调用 test1() 方法时局部变量 i,会在每个线程的栈帧内存中被创建多份,因此不存在共享
如图
1.4 局部变量引用的对象线程安全分析
1.4.1 案例: 全局变量对象
代码:
public class TestThreadSafe {
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 + 1)).start();
}
}
}
class ThreadUnsafe {
ArrayList<String> list = new ArrayList<>();
public void method1(int loopNumber) {
for (int i = 0; i < loopNumber; i++) {
method2();
method3();
}
}
// 直接操作list
private void method2() {
list.add("1");
}
// 直接操作list
private void method3() {
list.remove(0);
}
}
运行结果:
分析:
- 无论哪个线程中的 method2 引用的都是同一个对象中的 list 成员变量
- method3 与 method2 分析相同
图解:
1.4.1 案例: 全局变量对象(将上面 list 修改为局部变量)
代码:
import java.util.ArrayList;
public class TestThreadSafe {
static final int THREAD_NUMBER = 2;
static final int LOOP_NUMBER = 200;
public static void main(String[] args) {
ThreadSafe test = new ThreadSafe();
for (int i = 0; i < THREAD_NUMBER; i++) {
new Thread(() -> {
test.method1(LOOP_NUMBER);
}, "Thread" + (i + 1)).start();
}
}
}
class ThreadSafe {
public final 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");
}
private void method3(ArrayList<String> list) {
list.remove(0);
}
}
运行结果:
分析:
- list 是局部变量,每个线程调用时会创建其不同实例,没有共享
- 而 method2 的参数是从 method1 中传递过来的,与 method1 中引用同一个对象
- method3 的参数分析与 method2 相同
图解:
1.4.3 局部变量–暴露引用
示例代码:
import java.util.ArrayList;
public class TestThreadSafe {
static final int THREAD_NUMBER = 2;
static final int LOOP_NUMBER = 200;
public static void main(String[] args) {
ThreadSafeSubClass test = new ThreadSafeSubClass();
for (int i = 0; i < THREAD_NUMBER; i++) {
new Thread(() -> {
test.method1(LOOP_NUMBER);
}, "Thread" + (i + 1)).start();
}
}
}
class ThreadSafe {
public final 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");
}
public void method3(ArrayList<String> list) {
System.out.println(1);
list.remove(0);
}
}
class ThreadSafeSubClass extends ThreadSafe {
// 重写ThreadSafe的method3方法 在方法里面又开启一个线程去操作list
@Override
public void method3(ArrayList<String> list) {
System.out.println(2);
new Thread(() -> {
list.remove(0);
}).start();
}
}
运行结果:
原因:
- 因为重写了method3方法,在里面重新开启了一个新的线程,所以新的线程和原来的线程同时去操作list,发生了互斥。
- 如果没有控制子类的行为,就有可能造成局部变量的引用暴露给其他的线程,从而发生线程安全问题,所以我们一个限制子类的行为
解决方法: 把父类设置操作资源的方法设置为私有,这样子类就不可以重写它了。把操作资源的公共方法设置为final,这样子类就不可以重写公共方法。
从这个例子可以看出 private 或 final 提供【安全】的意义所在,请体会开闭原则中的【闭】
1.4.4 开闭原则:
上诉的示例代码的private 或 final 可以不让子类改变父类的行为
1.5 理解JDK 中 String 类的实现
源码:
思考: 为什么需要加final关键字修饰String呢?
如果不用final关键字修饰String类,那么String的子类就有可能覆盖父类中的行为,导致非线程安全的情况发生。String类很好的证明了闭合原则。
以上是关于JUC并发编程 -- 变量的线程安全问题(成员变量 & 静态变量 & 局部变量 & 开闭原则 & 理解JDK 中 String 类的实现)的主要内容,如果未能解决你的问题,请参考以下文章