【并发编程】多线程安全问题，如何避免死锁_多线程如何避免死锁

从今天开始阿Q将陆续更新java并发编程专栏，期待您的订阅。

在系统学习线程之前，我们先来了解一下它的概念，与经常提到的进程做个对比，方便记忆。

概念

线程和进程是操作系统中的两个重要概念，它们都代表了程序运行时的执行单位，它们的出现是为了更好地管理计算机资源和提高系统的运行效率，使用它们可以实现多任务同时运行，从而提高系统资源的利用率。

进程

进程是程序的一次执行过程，系统运行的每一个程序都是一个进程，它是操作系统资源分配的最小单位，也是系统运行程序的基本单位。

在同一个操作系统中，多个进程可以并发执行，每个进程都拥有各自独立的内存空间，相互之间不会产生影响。如下图，windows 系统的任务管理器页面运行的进程就对应着一个一个的应用。

在 Java 中，启动 main 函数就是启动了一个 JVM 进程，而 main 函数所在的线程就是进程中的一个线程，也称主线程。

线程

线程是比进程更小的执行单位，一个进程中包含多个线程，通过 JMX 来看看一个普通的 Java 程序有哪些线程：

public class MultiThread {
    public static void main(String[] args) {
            // 获取 Java 线程管理 MXBean
            ThreadMXBean threadMXBean = ManagementFactory.getThreadMXBean();
            // 不需要获取同步的 monitor 和 synchronizer 信息，仅获取线程和线程堆栈信息
            ThreadInfo[] threadInfos = threadMXBean.dumpAllThreads(false, false);
            // 遍历线程信息，仅打印线程 ID 和线程名称信息
            for (ThreadInfo threadInfo : threadInfos) {
                    System.out.println("[" + threadInfo.getThreadId() + "] " + threadInfo.getThreadName());
            }
    }
}

/**
执行结果：
[5] Attach Listener //添加事件
[4] Signal Dispatcher // 分发处理给 JVM 信号的线程
[3] Finalizer //调用对象 finalize 方法的线程
[2] Reference Handler //清除 reference 线程
[1] main //main 线程,程序入口
*/
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

线程共享所属进程的堆和方法区，独有程序计数器、虚拟机栈、本地方法栈等资源。如下图：红色为线程共享区域，蓝色为线程独占区域。

线程的创建、销毁、切换的开销比进程小，能够更快地完成任务，并且可以充分利用多核处理器的优势，所以又被称为轻量级进程。同一进程的线程间可能会进行资源的交互，而进程间是不存在的。

对比

总的来说，进程与线程的区别主要有以下几点：

• 进程是操作系统分配资源的最小单位，而线程是CPU调度的最小单位。
• 进程之间相互独立，拥有各自独立的内存空间，线程之间共享进程的内存空间。
• 进程切换开销大，线程切换开销小。
• 进程间通信复杂，线程间通信简单。

代码使用

进程

在 java 代码中通过使用 ProcessBuilder 类来创建一个名为 notepad.exe 的进程，即打开记事本应用程序。

public class CreateProcessTest {
    public static void main(String[] args) {
        try {
            ProcessBuilder processBuilder = new ProcessBuilder("notepad.exe");
            Process process = processBuilder.start();

            int exitCode = process.waitFor();
            System.out.println("进程已结束，退出码为：" + exitCode);
        } catch (IOException | InterruptedException e) {
            e.printStackTrace();
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13

然后调用 waitFor() 方法等待进程结束，并获取进程的退出码。

最后运行这个程序，会看到一个新的记事本窗口弹出来，这就是我们创建的进程。

当关闭记事本窗口时，程序会继续执行，输出进程的退出码。

线程

使用 Thread 类来创建一个新的线程：在 Thread 构造函数中，传入一个 Runnable 接口的实现，该实现定义了线程的任务。

这里只是简单地输出一些信息并模拟一个耗时任务。

public class CreateThreadTest {
    public static void main(String[] args) {
        // 创建一个新的线程
        Thread thread = new Thread(() -> {
            System.out.println("线程开始执行");
            try {
                Thread.sleep(10000); // 模拟线程执行耗时任务
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("线程执行完成");
        });
        // 启动线程
        thread.start();
        System.out.println("主线程继续执行");
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

然后调用 start() 方法来启动线程，当线程启动后，它会执行 run() 方法中定义的任务，同时主线程会继续执行。

执行结果如下：

主线程继续执行
线程开始执行
线程执行完成
1
2
3

线程创建方式

①. 继承Thread类创建线程类

• 定义 Thread 类的子类，并重写该类的 run() 方法，该 run() 方法的方法体就代表了线程要完成的任务。因此把 run() 方法称为执行体。

• 创建 Thread 子类的实例，即创建了线程对象。

• 调用线程对象的 start() 方法来启动该线程。

public class MyThread extends Thread {

    @Override
    public void run() {
        System.out.println("1111111");
    }

    public static void main(String[] args) {
        MyThread thread = new MyThread();
        thread.start();
    }
}
1
2
3
4
5
6
7
8
9
10
11
12

②. 通过 Runnable 接口创建线程类

• 定义 Runnable 接口的实现类，并重写该接口的 run() 方法，该 run() 方法的方法体同样是该线程的线程执行体。

• 创建 Runnable 实现类的实例，并依此实例作为 Thread 的 target 来创建 Thread 对象，该 Thread 对象才是真正的线程对象。

• 调用线程对象的 start() 方法来启动该线程。

public class MyThread implements Runnable {

    @Override
    public void run() {
        System.out.println("1111111");
    }

    public static void main(String[] args) {
        MyThread thread = new MyThread();
        Thread threadNew = new Thread(thread);
        threadNew.start();
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14

③. 通过 Callable 和 Future 创建线程

• 创建 Callable 接口的实现类，并实现 call() 方法，该 call() 方法将作为线程执行体，并且有返回值。

• 创建 Callable 实现类的实例，使用 FutureTask 类来包装 Callable 对象，该 FutureTask 对象封装了该 Callable 对象的 call() 方法的返回值。

• 使用 FutureTask 对象作为 Thread 对象的 target 创建并启动新线程。

• 调用 FutureTask 对象的 get() 方法来获得子线程执行结束后的返回值。

public class MyThread implements Callable {

    @Override
    public Object call() throws Exception {
        return 1+1;
    }

    public static void main(String[] args) {
        MyThread myThread = new MyThread();
        FutureTask futureTask = new FutureTask<>(myThread);
        new Thread(futureTask).start();
        Object o = null;
        try {
            o = futureTask.get();
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }
        System.out.println(o.toString());
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

线程的生命周期和状态

• NEW: 初始状态，线程被创建出来但没有被调用 start() 。
• RUNNABLE: 运行状态，线程被调用了 start() 等待运行的状态。
• BLOCKED ：阻塞状态，需要等待锁释放。
• WAITING：等待状态，表示该线程需要等待其他线程做出一些特定动作（通知或中断）。
• TIME_WAITING：超时等待状态，可以在指定的时间后自行返回而不是像 WAITING 那样一直等待。
• TERMINATED：终止状态，表示该线程已经运行完毕。

线程创建之后它将处于 NEW（新建） 状态，调用 start() 方法后开始运行，线程这时候处于 READY（可运行） 状态。可运行状态的线程获得了 CPU 时间片（timeslice）后就处于 RUNNING（运行） 状态。

操作系统层面，线程有 READTY 和 RUNNING 两种状态，而在 JVM 层面，只有 RUNNABLE 一种状态，因为每个线程在获取到 CPU 时间片时只会运行 0.01秒左右就会被切换执行其他的线程，线程切换速度之快，就没必要区分这两种状态了。

停止线程

在 Java 中，可以通过调用线程的 interrupt() 方法来中止线程。但是这并不意味着线程会立即停止执行，它只是设置了一个中断标志，线程可以通过检查这个标志来自行终止。 具体来说，当线程被中断时，可以通过以下方式来检查中断标志：

1. 调用 Thread.currentThread().isInterrupted() 方法检查当前线程是否被中断。
2. 调用 Thread.interrupted() 方法检查当前线程是否被中断，并清除中断状态。

在实际应用中，如果需要中止一个线程，可以在执行任务的循环中检查中断标志，如果中断标志被设置，则退出循环，从而中止线程的执行。

方法介绍

• Thread.sleep(long millis)，一定是当前线程调用此方法，当前线程进入阻塞，但不释放对象锁，millis 后线程自动苏醒进入可运行状态。作用：给其它线程执行机会的最佳方式。
• Thread.yield()，一定是当前线程调用此方法，当前线程放弃获取的 cpu 时间片，由运行状态变会可运行状态，让 OS 再次选择线程。作用：让相同优先级的线程轮流执行，但并不保证一定会轮流执行。实际中无法保证 yield() 达到让步目的，因为让步的线程还有可能被线程调度程序再次选中。Thread.yield() 不会导致阻塞。
• obj.wait()，当前线程调用对象的 wait() 方法，当前线程释放对象锁，进入等待队列。依靠 notify()/notifyAll() 唤醒或者 wait(long timeout) timeout 时间到自动唤醒。
• t.join()/t.join(long millis)，当前线程里调用其它线程1的 join 方法，当前线程阻塞，但不释放对象锁，直到线程1执行完毕或者 millis 时间到，当前线程进入可运行状态。
• obj.notify() 唤醒在此对象监视器上等待的单个线程，选择是任意性的。
• notifyAll() 唤醒在此对象监视器上等待的所有线程。

sleep() / wait()

共同点 ：两者都可以暂停线程的执行。

区别 ：

• sleep() 方法不释放锁， wait() 方法释放锁；
• wait() 通常被用于线程间交互/通信，sleep() 通常被用于暂停执行。
• wait() 方法被调用后，线程不会自动苏醒，需要别的线程调用同一个对象上的 notify() 或者 notifyAll() 方法。sleep() 方法执行完成后，线程会自动苏醒，或者也可以使用 wait(long timeout) 超时后线程会自动苏醒。
• sleep() 是 Thread 类的静态本地方法，wait() 则是 Object 类的本地方法。

为什么 wait() 不被定义在 Thread 中？sleep() 定义在 Thread 中？

wait 是想让获得对象锁的线程暂停执行，会自动释放当前线程占有的对象锁。每个对象都有对象锁，既然要释放对象锁，就得对对象进行操作。

因为 sleep() 是让当前线程暂停执行，不需要获得对象锁，所以不涉及到对象类。

run()/start()

• 通过调用 Thread 类的 start() 方法来启动一个线程，真正实现了多线程运行。这时无需等待 run 方法体代码执行完毕，可以直接继续执行下面的代码； 这时此线程是处于就绪状态， 并没有运行。 然后通过此 Thread.start() 调用方法 run() 来完成其运行状态， 这里方法 run() 称为线程体，它包含了要执行的这个线程的内容， run() 方法运行结束， 此线程终止。然后CPU再调度其它线程。
• run() 方法是在本线程里的，只是线程里的一个函数, 而不是多线程的。 如果直接调用run()，其实就相当于是调用了一个普通函数而已，直接调用 run() 方法必须等待 run() 方法执行完毕才能执行下面的代码，所以执行路径还是只有一条，根本就没有线程的特征，所以在多线程执行时要使用 start() 方法而不是 run() 方法。

为什么使用多线程？

• 单个线程被IO阻塞，其它线程还可以获取 cpu，提高系统资源的利用率。
• 线程被称为轻量级的进程，它的切换与调度成本远远小于进程。
• 利用好多线程机制可以大大提高系统整体的并发能力以及性能。
• 现在到了多核的时代，多个线程可以并行执行，减少了线程上下文切换的开销。

CPU 通过给每个线程分配 CPU 时间片 来实现线程切换，在进行线程切换时需要保存当前线程正在执行任务的状态（也就是我们所说的上下文），以便下次切回到这个任务时，还可以继续执行该任务，即任务从保存到再加载的过程就是一次上下文切换。

多线程的缺点：多线程并发执行可能会导致内存泄漏、死锁、线程不安全等问题。

线程安全问题

在 Java 中，多线程并发操作同一个共享变量时，就可能会发生线程安全问题。 在 Java 中保证线程安全的常用手段有以下三个：

1. 使用锁机制：锁机制是一种用于控制多个线程对共享资源进行访问的机制。在 Java 中，锁机制主要有两种：synchronized 关键字和 Lock 接口。synchronized 关键字是 Java 中最基本的锁机制，它可以用来修饰方法或代码块，以实现对共享资源的互斥访问。而 Lock 接口是 Java5 中新增的一种锁机制，它提供了比 synchronized 更强大、更灵活的锁定机制，例如可重入锁、读写锁等；
2. 使用线程安全的容器：如 ConcurrentHashMap、Hashtable、Vector。需要注意的是，线程安全的容器底层通常也是使用锁机制实现的；
3. 使用本地变量：线程本地变量是一种特殊的变量，它只能被同一个线程访问。在 Java 中，线程本地变量可以通过 ThreadLocal 类来实现。每个 ThreadLocal 对象都可以存储一个线程本地变量，而且每个线程都有自己的一份线程本地变量副本，因此不同的线程之间互不干扰。

线程死锁

多个线程同时被阻塞，他们都在等待某个资源被释放，由于线程无限期的阻塞，导致程序不可能正常终止，我们把这种现象称为死锁。

如下图所示，线程1拥有资源A的锁A，想要获取资源B的锁B，但是此时资源B的锁B正被线程2拥有，而线程2却想要获取线程1拥有的锁A，所以俩线程会无限等待，造成死锁。

如何避免死锁？

产生死锁的四个必要条件

• 互斥条件：该资源任意一个时刻只由一个线程占用。
• 请求与保持条件：一个线程因请求资源而阻塞时，对已获得的资源保持不放。
• 不剥夺条件：线程已获得的资源在未使用完之前不能被其他线程强行剥夺，只有自己使用完毕后才释放资源。
• 循环等待条件：若干线程之间形成一种头尾相接的循环等待资源关系。

如何预防和避免线程死锁?

破坏死锁的产生的必要条件即可：

• 破坏请求与保持条件 ：一次性申请所有的资源。
• 破坏不剥夺条件 ：占用部分资源的线程进一步申请其他资源时，如果申请不到，可以主动释放它占有的资源。
• 破坏循环等待条件 ：靠按序申请资源来预防。按某一顺序申请资源，释放资源则反序释放。破坏循环等待条件。

总结

本文我们从大家熟知的线程和进程入手，通过对比他俩的使用场景、代码使用来方便记忆。随后对线程的创建方式以及生命周期进行了详细的讲解。然后介绍了线程使用过程中的一些方法，方便大家更好的入手。最后对多线程的安全问题和死锁问题进行了总结，希望大家做到温故而知新，要不然很容易忘记概念性的东西。