线程的状态，多线程带来的风险，synchronized关键字及死锁问题-Toy模板网

这篇具有很好参考价值的文章主要介绍了线程的状态，多线程带来的风险，synchronized关键字及死锁问题。希望对大家有所帮助。如果存在错误或未考虑完全的地方，请大家不吝赐教，您也可以点击"举报违法"按钮提交疑问。

目录

状态

线程的意义

多线程带来的风险——线程安全✅

线程安全的概念

线程不安全的原因

抢占式执行，随机性调度

修改共享数据

原子性->加🔒

可见性

指令重排序

解决线程不安全问题（学完线程再总结）

synchronized关键字——监视器锁monitor lock编辑

互斥

使用示例

可重入

Java标准库中线程安全的类

死锁

1.死锁是什么

2.死锁的三个典型情况

3.死锁的四个必要条件编辑

4.如何破除死锁？

状态是针对当前的线程调度情况进行描述的，所以认为线程是程序调度的基本单位（后面再谈状态都是考虑线程的状态了）；

状态

public class ThreadState {
    public static void main(String[] args) {
        for (Thread.State state : Thread.State.values()) {
            System.out.println(state);
       }
   }
}
1. NEW : 创建Thread对象，但是还没调用start(内核还没创建对应的PCB)；

2. TERMINATED : 内核中的PCB已经创建完毕了，但是Thread对象还在；

3. RUNNABLE：可运行的；（RUNNABLE是正在CPU上执行的，RUNNING是在就绪队列上的，可以去CPU上执行的）；

4. WAITING

5. TIMED_WAITING

6. BLOCKED

上述三个都是阻塞，表示线程 PCB 正在阻塞队列中，但是原因不同

RUNNABLE表示就绪状态，包含正在CPU上运行，或者在就绪队列中排队；

当有for循环里有sleep的时候，t运行中的状态大部分是TIMED_WAITING, 为了让时间均衡，可以给 t 线程中添加更多的计算逻辑。

如果线程代码中全是for循环里计算，比较大小之类的操作，此时这个线程就不会阻塞，始终是RUNNABLE'状态；

所以，之前我们学过的 isAlive() 方法，可以认为是处于不是 NEW 和 TERMINATED 的状态都是活着 的。

线程的意义

程序分成：

CPU密集：包含大量的加减乘除运算符；

IO密集：涉及到读写文件，读写控制台，读写网络的操作；

多线程可以更充分的利用到多核心cpu的资源

多线程带来的风险——线程安全✅

起源于多线程的抢占式执行带来的随机性。如果没有多线程，程序的执行顺序就是固定的；调度的源头来自于操作系统的内核实现

线程安全的概念

多个线程同时对某个共享资源进行访问导致的原子性，可见性，有序性的问题，这些问题导致共享资源存在一个不可预测性，使执行结果出现不可预期的结果。

如果多线程环境下代码运行的结果是符合我们预期的，即在单线程环境应该的结果，则说这个程序是线 程安全的。

线程不安全的原因

抢占式执行，随机性调度

修改共享数据

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

string都是不可变对象，所以他线程安全

原子性->加🔒

是不可拆分的基本单位，针对线程安全问题最主要的的手段就是通过加锁将非原子的转换为“原子”的，

我们把一段代码想象成一个房间，每个线程就是要进入这个房间的人。如果没有任何机制保证， A 进入房间之后，还没有出来；B 是不是也可以进入房间，打断 A 在房间里的隐私。这个就是不具备原子性的。

那我们应该如何解决这个问题呢？是不是只要给房间加一把锁， A 进去就把门锁上，其他人是不是就进不来了。这样就保证了这段代码的原子性了。

有时也把这个现象叫做同步互斥，表示操作是互相排斥的。

一条 java 语句不一定是原子的，也不一定只是一条指令

比如 n++ ，其实是由三步操作组成的：

1. 从内存把数据读到 CPU

2. 进行数据更新

3. 把数据写回到 CPU

不保证原子性会给多线程带来什么问题

如果一个线程正在对一个变量操作，中途其他线程插入进来了，如果这个操作被打断了，结果就可能是错误的。

这点也和线程的抢占式调度密切相关 . 如果线程不是 " 抢占 " 的 , 就算没有原子性 , 也问题不大 .

可见性

如果一个线程读，一个线程改，也可能出现问题。

指令重排序

编译器对于指令重排序的前提是 " 保持逻辑不发生变化 ". 这一点在单线程环境下比较容易判断 , 但

是在多线程环境下就没那么容易了 , 多线程的代码执行复杂程度更高 , 编译器很难在编译阶段对代

码的执行效果进行预测 , 因此激进的重排序很容易导致优化后的逻辑和之前不等价 .

解决线程不安全问题（学完线程再总结）

同步代码块

同步方法

锁

synchronized关键字——监视器锁monitor lock

互斥

当两个线程同时对一个对象进行加锁的时候，会出现锁冲突/锁竞争，一个线程可以获取到锁另一个线程出现线程阻塞的情况，直到那个线程解锁，它才取锁成功。

两个线程，一个加锁，一个不加锁，不存在锁竞争；

两个线程针对不同对象加锁，俩线程获取到各自的锁，此时不存在锁竞争；

同一个对象 synchronized 就会 阻塞等待 .

进入 synchronized 修饰的代码块 , 相当于加锁

退出 synchronized 修饰的代码块 , 相当于解锁

synchronized 用的锁是存在 Java 对象头里的。

文章来源地址https://www.toymoban.com/news/detail-459691.html

使用示例

synchronized关键字

修饰方法（普通方法-加到this对象上，静态方法-加到类对象上）

代码块-手动指定加到某个对象上

ctrl+alt+t->选中代码块包裹

可重入

一个线程针对同一个对象，连续加锁两次如果没有问题，就叫可重入的，否则不可重入（第二次加锁就会出现阻塞等待的情况，这种情况线程就僵住了，出现死锁现象）。

这里的死锁（死锁的一种情况）如何理解？

灵异事件：滑稽老铁去厕所，锁上了门，结果时空错乱，它出来了，忘记了去厕所这件事，去厕所发现门一直都是锁的。

为了避免上述死锁，java将synchronized设定为可重入的。

上述图片可以理解为：

我追到男神，追的过程中给他表白了一次，追到手后再表白了一次，就是“可重入的”，不会出现阻塞等待等。

synchronized 同步块对同一条线程来说是可重入的，不会出现自己把自己锁死的问题；

eg:
static class Counter {
    public int count = 0;
    synchronized void increase() {
        count++;
   }
    synchronized void increase2() {
        increase();
   }
}
在可重入锁的内部 , 包含了 " 线程持有者 " 和 " 计数器 " 两个信息 .

1. 如果某个线程加锁的时候 , 发现锁已经被人占用 , 但是恰好占用的正是自己 , 那么仍然可以继续获取到锁, 并让计数器自增 .

2. 解锁的时候计数器递减为 0 的时候 , 才真正释放锁 . ( 才能被别的线程获取)

Java标准库中线程安全的类

多个线程操作同一个集合类，就要考虑到线程安全问题。

还有的类不涉及加锁，但仍然是线程安全的，因为不涉及修改操作：String;

死锁

1.死锁是什么

死锁是两个或两个以上的线程在执行过程中，去争夺同一个共享资源导致的互相等待的过程，在没有外部干预的情况下，线程会一直处于阻塞状态，无法向下执行。

死锁比较隐蔽，一旦写了死锁，会出现严重的bug

2.死锁的三个典型情况
一个线程，一把锁，连续锁两次，如果锁是不可重入性锁，就会死锁；Java里的synchronized和ReentrantLock都是可重入性锁；
循环等待：两个线程，两把锁，t1，t2先各自针对锁A，锁B进行加锁，再尝试获取对方的锁。线程1在获取B的时候等待线程2释放B，线程2在获取A的时候等待线程1释放A，造成blocked；(线程1拿到A锁，再尝试获取锁B，A这把锁还是继续保持的，不会因为要去获取B就把A释放了)
public class demo33 {
    public static void main(String[] args) {
        Object jiangyou=new Object();
        Object cu=new Object();
        Thread tanglaoshi=new Thread(()->{
            synchronized(jiangyou){
                try {
                    Thread.sleep(10);
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
                synchronized (cu){
                    System.out.println("汤老师拿到了酱油和醋");
                }
            }
        });
         Thread shiniang=new Thread(()->{
            synchronized(cu){
                try {
                    Thread.sleep(10);
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
                synchronized (jiangyou){
                    System.out.println("师娘拿到了酱油和醋");
                }
            }
        });
    }
}
//用jconsole定位到这两个线程的第二个🔒操作出现了BLOCKED操作；
多个线程，多把锁
当他们都拿起左手的筷子就会出现极端情况。
3.死锁的四个必要条件

4.如何破除死锁？

去破坏死锁中的必要条件中的任意一个（除了互斥条件），给锁编号，然后制定一个固定的顺序（从小到大）来加锁，任意线程加多把锁的时候，都让线程遵循上述循序，此时循环等待自然破除。eg:对于上面的代码就可以通过把锁的内容换一下。

还有解决死锁的银行家算法。