👏作者简介：大家好，我是笙一X，java大二练习生，喜欢算法和java相关知识。
📕正进行的系列：算法 、JUC从入门到成神
目录
有关 “线程八锁” ——— 考察 synchronized 锁住的是哪个对象
共享资源时的问题
我们来看看一段代码，想想会出现什么问题？
public static int count = 0;
public static void main(String[] args) throws InterruptedException {
Thread t1 = new Thread(() -> {
for (int i = 0; i < 10000; i++) {
count++;
}
}, "t1");
Thread t2 = new Thread(() -> {
for (int i = 0; i < 10000; i++) {
count--;
}
}, "t2");
t1.start();
t2.start();
t1.join();
t2.join();
log.debug("count:{}", count);
}经过运行，我们得到：
18:54:56.332 [main] DEBUG com.sheng1.jucBase.Test1 - count:-181
但是照理来说，共享变量 count 的 “++” 次数和 “--”次数一样，结果不应该还是为0吗？
问题分析
有的同学可能知道，Java对静态变量的自增自减并不是原子操作。我们从字节码来分析：
如果主存中存储了一个变量 i，
对于 i++ 而言，会产生以下JVM字节码指令：
getstatic i //获取静态变量i的值
iconst_1 //准备常量1
iadd //自增
putstatic i //将修改后的值存入静态变量i对于 i-- 而言，一样如此：
getstatic i //获取静态变量i的值
iconst_1 //准备常量1
isub //自减
putstatic i //将修改后的值存入静态变量i我们可以通过一个图知道此时主存和工作内存中 i 的数据交换：
因为自增自减不是原子性操作，我们会发现可能造成指令交错的问题，在一个操作进行到一半就进行了上下文切换到另一个线程执行另一个操作。
如：主存内 i 为0，在线程1中，我们刚将 i 自增完，得到1的结果，还没来得及放入主存，就切换到线程2。此时的线程2拿到的是还没更新的 i ，值为0，经过自减和存入使得主存内 i 更新为-1。然后再进行线程切换，而因为之前操作系统保存了之前线程1的状态，所以下一条JVM指令就是将 1 更新到了主存当中，令当前 i 的值为1。
synchronized 解决
在认识synchronized之前，我们先了解两个名词：
1. 临界区 Critical Section
-
一个程序运行多个线程本身是没有问题的
-
问题出在多个线程访问共享资源
-
多个线程共享资源其实也没有问题
-
在多个线程对共享资源读写操作时发生指令交错，就会出现问题
-
-
一段代码块内如果存在对共享资源的多线程读写操作，称这段代码块为临界区
2.竞态条件 Race Condition
多个线程在临界区内执行，由于代码的执行序列不同而导致结果无法预测，称之竞态条件
介绍synchronized
其实为了避免临界区的竞态条件发生，有多种手段可以达到目的。
-
阻塞式的解决方案：synchronized，Lock
-
非阻塞式的解决方案：原子变量
而synchronized，即俗称的【对象锁】，它采用互斥的方式让同一时刻至多只有一个线程能持有【对象锁】，其它线程再想获取这个【对象锁】时就会阻塞住。这样就能保证拥有锁的线程可以安全的执行临界区内的代码，不用担心线程上下文切换
打个比方，如果共享资源在一间上了锁的屋子里，你想要进去拿资源，就必须要等别的线程把屋子的钥匙给你才能进去，否则就得一直等着。
注意：
虽然 java 中互斥和同步都可以采用 synchronized 关键字来完成，但它们还是有区别的：
-
互斥是保证临界区的竞态条件发生时，同一时刻只能有一个线程执行临界区代码
-
同步是由于线程执行的先后、顺序不同、需要一个线程等待其它线程运行到某个点
语法：
sychronized(对象) {
// 临界区代码
} 基于之前的代码，我们这样解决：
public static int count = 0;
public final Object room = new Object();
public static void main(String[] args) throws InterruptedException {
Thread t1 = new Thread(() -> {
for (int i = 0; i < 10000; i++) {
synchronized(room) {
count++;
}
}
}, "t1");
Thread t2 = new Thread(() -> {
for (int i = 0; i < 10000; i++) {
synchronized(room) {
count--;
}
}
}, "t2");
t1.start();
t2.start();
t1.join();
t2.join();
log.debug("count:{}", count);
}深度理解一下：
synchronized 实际是用对象锁保证了临界区内代码的原子性，临界区内的代码对外是不可分割的，不会对被线程切换所打断。
为了加深理解，请思考下面的问题
-
如果把synchronized（obj）放在for循环外面，如何理解？ -- 必须等我搞完所有事情，你才能用
-
如果 t1 synchronized（obj1）而 t2 synchronized（obj2）会怎样运作？ -- 两个屋子，互不干扰
-
如果 t1 synchronized（obj）而 t2 没有加，如何理解？ -- t1的锁对 t2 无作用，照样进出。
我们来做个小扩展：
有关 “线程八锁” ——— 考察 synchronized 锁住的是哪个对象
"线程八锁"是指在Java中通过synchronized关键字实现同步时可能出现的八种情况，也称为 "锁的八种状态"。这些情况是由于synchronized关键字的不同使用方式导致的。这八种情况主要涉及到两个概念：对象锁和类锁。
-
对象锁：对象锁是实例级别的锁，它作用于实例对象上。当一个线程获取了某个实例对象的锁，其他线程就不能同时获取该对象的锁，需要等待锁释放。
-
类锁：类锁是类级别的锁，它作用于类的 Class 对象上。当一个线程获取了某个类的锁，其他线程就不能同时获取该类的锁，需要等待锁释放。
下面是八种情况的具体描述：
-
对象锁-同步代码块（非静态）：synchronized(this)和synchronized(obj)，同一个实例对象的不同线程之间互斥，不同实例对象的线程之间不互斥。
-
对象锁-同步方法（非静态）：synchronized修饰非静态方法，同一个实例对象的不同线程之间互斥，不同实例对象的线程之间不互斥。
-
对象锁-同步代码块（静态）：synchronized修饰静态方法，同一个实例对象的不同线程之间互斥，不同实例对象的线程之间不互斥。
-
对象锁-同步方法（静态）：synchronized(this)和synchronized(obj)，不同实例对象的线程之间互斥，同一个实例对象的不同线程之间也互斥。
-
类锁-同步代码块（静态）：synchronized修饰静态方法，同一个类的不同实例对象的线程之间互斥。
-
类锁-同步方法（静态）：synchronized修饰静态方法，同一个类的不同实例对象的线程之间互斥。
-
类锁和对象锁互不影响：即一个线程访问对象锁时，另一个线程可以同时访问该类的类锁。
-
锁升级：当一个线程访问对象的同步代码块时，另一个线程可以访问该类的非静态同步方法；反之，当一个线程访问类的非静态同步方法时，另一个线程可以访问该对象的同步代码块。
变量的线程安全分析
成员变量和静态变量是否线程安全？
-
如果它们没有共享，则线程安全
-
如果它们被共享了，根据它们的状态是否能够改变，又分两种情况
-
如果只有读操作，则线程安全
-
如果有读写操作，则这段代码是临界区，需要考虑线程安全
-
局部变量是否线程安全？
-
局部变量是线程安全的
-
但局部变量引用的对象则未必
-
如果该对象没有逃离方法的作用访问，它是线程安全的
-
如果该对象逃离方法的作用范围，需要考虑线程安全
-
局部变量线程安全分析
public static void test1(){
int i = 10;
i++;
}每个线程调用 test1（） 方法时局部变量 i ，会在每个线程的栈帧内存中被创建多份，因此不存在共享
局部变量的引用稍有不同
先看一个成员变量的例子
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);
}
}
执行
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();
}
}其中一种情况是，如果线程2还未add，线程1 remove就会报错
分析：
-
无论哪个线程中的 method2 引用的都是同一个对象中的 list 成员变量
-
method3 与 method2 分析相同
但如果把list也作为局部变量，就不会有这样的问题
class ThreadSafe{
public void method1(int loopNumber){
ArrayList<String> list = new ArrayList<>();
for(int i = 0; i < loopNumber; i++){
// { 临界区，会产生竞态条件
method2();
method3();
// } 临界区
}
}
private void method2(ArrayList<String> list){
list.add("1");
}
private void method2(ArrayList<String> list){
list.remove(0);
}
}分析：
-
list 是局部变量，每个线程调用时会创建不同实例，没有共享
-
而 method2 的参数是从 method1 中传递过来的，与 method1 中引用同一个对象
-
method3 的参数分析与 method2 相同
暴露引用
我们再思考一下，如果把 method2 和 method3 的方法修改为 public 会不会带来线程安全问题？
没有问题，因为线程2调用的method2中的参数不会是线程1中的 list
但是，如果我们在上述情况 的基础上，为ThreadSafe类添加子类，子类覆盖 method2 或 method3 方法，即
class ThreadSafe{
public void method1(int loopNumber){
ArrayList<String> list = new ArrayList<>();
for(int i = 0; i < loopNumber; i++){
// { 临界区，会产生竞态条件
method2();
method3();
// } 临界区
}
}
public void method2(ArrayList<String> list){
list.add("1");
}
public void method2(ArrayList<String> list){
list.remove(0);
}
}
class ThreadSafeSubClass extends ThreadSafe{
@Override
public void method3(ArrayList<String> list){
new Thread(() -> {
list.remove(0);
}).start();
}
}会产生问题
所以，我们的方法权限修饰符是有意义的，一定程度上可以保证线程安全。从这个例子可以看出 private 或 final 提供【安全】的意义所在，请体会开闭原则中的【闭】
另外建议在 method1 前写一个 final ，防止子类重写，覆盖方法
不可变类线程安全性
String、Integer等都是不可变类，因为其内部的状态不可以改变，因此它们的方法都是线程安全的
你或许有疑问，String有replace，substring等方法【可以】改变值啊，那么这些方法又是如何保证线程安全的呢？
我们学习其中的源码可以发现，String其实内部存储的是final char[] ，所有这些方法不是改变值，而是创建了一个新的String。
总结
了解了共享，我们算是初入多线程的大门。JUC的世界非常有趣，我们慢慢发现！我是笙一X，一个正在努力拼搏的人，感谢你的支持，同时期待交流和指导。
扫一扫
4171
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
