时常在面试中被问到的多线程问题：上篇-CSDN博客

本文链接：https://blog.csdn.net/qq_27575627/article/details/139167437

文章目录

进程和线程有什么区别？
多线程有什么优缺点？
- - 优点
  - 缺点
线程的创建方式有哪些？
如何简单的使用线程？
用户线程和守护线程有什么区别？
线程经常用的方法有哪些
start 和 run 方法有什么区别？
- - `start()` 方法
  - `run()` 方法
wait 方法和 sleep 方法有什么区别？
- - `sleep` 方法
  - `wait` 方法
说一下线程的生命周期？
说一下Object.wait()和Thread.join()之间的区别
怎么终止线程？
介绍一下volatile关键字
说一下Object.wait()和Thread.join()之间的区别
- - Object.wait()
  - Thread.join()

进程和线程有什么区别？

进程（Process）和线程（Thread）是操作系统中两个重要的概念，它们在计算机程序的执行和资源管理中扮演不同的角色。

一个进程可以包含多个线程，所有线程共享进程的资源（如内存、文件描述符等）。进程提供了更高的隔离性和独立性，但代价是较高的资源开销和通信复杂性。线程提供了更高的效率和通信便捷性，但需要仔细处理同步问题以避免竞争条件。根据具体应用场景的需求，可以选择适合的并发模型。

以下是它们的主要区别：

定义

进程：进程是一个程序在其自身的地址空间中运行的实例。每个进程都有自己的内存空间、数据段、代码段和系统资源（如文件描述符、设备等）。
线程：线程是进程中的一个执行路径。一个进程可以包含多个线程，所有线程共享进程的资源（如内存、文件描述符等）。

内存空间

进程：进程有独立的内存空间。一个进程的内存空间通常包括代码段、数据段、堆栈段等。
线程：线程共享所属进程的内存空间，因此多个线程可以访问相同的变量和数据结构。这也意味着线程之间的通信更为高效，但同时也需要更加小心处理同步问题。

资源开销

进程：由于进程具有独立的内存空间和系统资源，创建和销毁进程的开销相对较大（如上下文切换、内存分配等）。
线程：线程共享进程的资源，创建和销毁线程的开销比进程小得多。线程的上下文切换也比进程更快。

通信方式

进程：进程之间的通信（IPC，Inter-Process Communication）相对复杂，需要通过操作系统提供的机制（如管道、消息队列、共享内存等）。
线程：线程之间的通信相对简单，因为线程共享进程的内存空间，可以直接通过共享变量进行通信。但这也要求使用同步机制（如锁、信号量等）来防止竞争条件。

独立性

进程：进程是独立的执行单元，一个进程的崩溃不会影响到其他进程。
线程：线程是依赖于进程的，一个线程的崩溃可能会导致整个进程的崩溃，因为它们共享相同的地址空间。

适用场景

进程：适用于需要高度隔离和独立性的任务，如不同用户的独立程序、系统服务等。
线程：适用于需要并发处理但共享大量数据的任务，如多线程服务器、并发计算等。

多线程有什么优缺点？

多线程编程是指在一个单一的程序中创建和管理多个线程，以便并发地执行任务。

多线程编程具有提高程序响应能力和执行效率的优点，但也带来了同步问题、上下文切换开销、调试难度和资源消耗等挑战。在使用多线程时，需要仔细权衡这些优缺点，并采取适当的设计和优化策略，以充分发挥其优势。

优点

提高程序的响应能力：
- 多线程能够使程序在等待某些操作（如I/O操作）完成时，继续执行其他任务，从而提高程序的响应速度。例如，GUI应用程序使用多线程可以确保用户界面在执行后台任务时仍然保持响应。
提升程序的执行效率：
- 通过将计算密集型任务划分为多个线程并行执行，可以充分利用多核处理器的性能，提高程序的执行效率和吞吐量。
资源共享：
- 线程共享相同的进程资源（如内存、文件句柄），这使得线程之间的数据共享和通信更加高效，避免了进程间通信的开销。
简化的设计：
- 对于一些复杂的并发任务，多线程模型可以使设计更为直观和简单。例如，在服务器应用中，每个客户端连接可以由一个独立的线程来处理，简化了任务管理的逻辑。

缺点

复杂的同步问题：
- 由于多个线程共享相同的内存空间，因此需要使用同步机制（如锁、信号量、条件变量等）来避免竞争条件和数据不一致问题。这增加了编程的复杂性，并且不当的同步可能导致死锁、活锁等问题。
上下文切换开销：
- 虽然线程的上下文切换比进程轻量，但频繁的线程切换仍然会带来一定的性能开销，尤其是在线程数量非常多的情况下，这种开销可能会显著影响程序的性能。
难以调试和测试：
- 多线程程序的行为具有非确定性，这使得调试和测试变得更加困难。多线程相关的bug（如竞争条件、死锁）通常难以重现和定位。
资源消耗：
- 创建和管理大量线程需要占用一定的系统资源（如线程栈空间、调度开销等）。在某些情况下，过多的线程可能会导致系统资源耗尽，影响程序和系统的稳定性。
可伸缩性问题：
- 在多核系统中，多线程程序可能会面临可伸缩性问题，特别是当线程数量超过处理器核心数量时，线程调度和上下文切换的开销会导致性能下降。此外，线程间同步机制可能会引入额外的开销，限制程序的可伸缩性。

线程的创建方式有哪些？

在Java中，线程的创建有几种主要方式，每种方式都有其特点和适用场景。以下是几种常见的线程创建方式：

继承Thread类：简单直接，但Java中只能继承一个类，因此局限性较大。
实现Runnable接口：更灵活，适合需要共享资源的任务。
匿名内部类和Lambda表达式：简化代码书写，适用于快速创建线程。
Executor框架：提供了更高级的线程管理功能，适合复杂的并发任务。

1. 继承Thread类

继承Thread类并重写其run方法，是创建线程的一种方式。这种方式适用于需要直接控制线程行为的情况。

class MyThread extends Thread {
    public void run() {
        // 线程执行的任务
        System.out.println("Thread is running.");
    }
}

public class Main {
    public static void main(String[] args) {
        MyThread thread = new MyThread();
        thread.start();  // 启动线程
    }
}

2. 实现Runnable接口

实现Runnable接口并将其实例传递给Thread对象，是另一种常见的创建线程的方式。这种方式更加灵活，因为一个类可以实现多个接口，而只能继承一个类。

class MyRunnable implements Runnable {
    public void run() {
        // 线程执行的任务
        System.out.println("Thread is running.");
    }
}

public class Main {
    public static void main(String[] args) {
        Thread thread = new Thread(new MyRunnable());
        thread.start();  // 启动线程
    }
}

3. 使用匿名内部类

可以使用匿名内部类的方式创建线程，通常用于简化代码，尤其是在需要快速创建和使用线程的情况下。

public class Main {
    public static void main(String[] args) {
        Thread thread = new Thread(new Runnable() {
            public void run() {
                // 线程执行的任务
                System.out.println("Thread is running.");
            }
        });
        thread.start();  // 启动线程
    }
}

4. 使用Lambda表达式（Java 8及以上）

在Java 8及以上版本中，可以使用Lambda表达式简化Runnable的实现，代码更加简洁。

public class Main {
    public static void main(String[] args) {
        Thread thread = new Thread(() -> {
            // 线程执行的任务
            System.out.println("Thread is running.");
        });
        thread.start();  // 启动线程
    }
}

5. 使用Executor框架

Executor框架提供了一种更为高级的线程管理方式，适用于需要管理大量线程或线程池的情况。

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class Main {
    public static void main(String[] args) {
        ExecutorService executor = Executors.newFixedThreadPool(10);  // 创建固定大小的线程池
        executor.submit(() -> {
            // 线程执行的任务
            System.out.println("Thread is running.");
        });
        executor.shutdown();  // 关闭线程池
    }
}

如何简单的使用线程？

要简单地使用线程，你可以选择继承Thread类或者实现Runnable接口。这两种方法是Java中最基本的线程创建和使用方式。

继承Thread类：直接创建一个新的线程类，适合简单的场景。
实现Runnable接口：更灵活，适合需要实现多重继承或者复杂逻辑的场景。
Lambda表达式：在Java 8及以上版本中，用于简化代码书写。

以上三种方法都可以用来简单地创建和启动线程，根据具体需求选择最适合的方式即可。

下面是这两种方法的详细步骤和示例代码。

方法1：继承Thread类

创建一个类继承Thread类。
重写run方法，将你想要在线程中执行的代码放入该方法中。
创建该类的实例，并调用start方法启动线程。

示例代码：

class MyThread extends Thread {
    @Override
    public void run() {
        // 线程执行的任务
        System.out.println("Thread is running.");
    }
}

public class Main {
    public static void main(String[] args) {
        MyThread thread = new MyThread();
        thread.start();  // 启动线程
    }
}

方法2：实现Runnable接口

创建一个类实现Runnable接口。
实现run方法，将你想要在线程中执行的代码放入该方法中。
创建该类的实例。
创建Thread对象，并将Runnable实例传递给Thread的构造函数。
调用Thread对象的start方法启动线程。

示例代码：

class MyRunnable implements Runnable {
    @Override
    public void run() {
        // 线程执行的任务
        System.out.println("Thread is running.");
    }
}

public class Main {
    public static void main(String[] args) {
        MyRunnable myRunnable = new MyRunnable();
        Thread thread = new Thread(myRunnable);
        thread.start();  // 启动线程
    }
}

使用Lambda表达式（Java 8及以上）

在Java 8及以上版本中，可以使用Lambda表达式简化Runnable的实现，使代码更为简洁。

示例代码：

public class Main {
    public static void main(String[] args) {
        Thread thread = new Thread(() -> {
            // 线程执行的任务
            System.out.println("Thread is running.");
        });
        thread.start();  // 启动线程
    }
}

用户线程和守护线程有什么区别？

在Java中，线程分为两种类型：用户线程（User Thread）和守护线程（Daemon Thread）。它们之间的主要区别在于它们对Java虚拟机（JVM）运行状态的影响以及它们的用途和行为。

用户线程：
- JVM会等待所有用户线程终止后才退出。
- 用于执行应用程序的主要逻辑。
守护线程：
- 当没有用户线程运行时，JVM会退出，不管守护线程是否还在运行。
- 用于执行后台支持任务。

以下是它们的详细区别：

用户线程（User Thread）

JVM运行状态：
- 用户线程是普通线程，JVM在任何用户线程运行时都会继续运行。只有当所有用户线程都终止时，JVM才会退出。
默认类型：
- 所有的线程默认都是用户线程，除非明确设置为守护线程。
用途：
- 用户线程通常用于执行应用程序的主要逻辑，例如处理请求、计算任务等。

守护线程（Daemon Thread）

JVM运行状态：
- 守护线程是用于为用户线程提供支持的后台线程。当所有用户线程都终止时，JVM会自动退出，不管是否有守护线程仍在运行。
设置方式：
- 可以通过调用Thread对象的setDaemon(true)方法将一个线程设置为守护线程。需要在调用start方法之前设置，否则会抛出IllegalThreadStateException异常。
用途：
- 守护线程通常用于执行后台任务，如垃圾回收、内存管理等，不要求在JVM退出时完成其任务。

示例代码

以下是一个演示用户线程和守护线程区别的简单示例：

public class Main {
    public static void main(String[] args) {
        // 用户线程
        Thread userThread = new Thread(() -> {
            try {
                Thread.sleep(5000);
                System.out.println("User thread finished.");
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });

        // 守护线程
        Thread daemonThread = new Thread(() -> {
            while (true) {
                System.out.println("Daemon thread is running.");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });
        daemonThread.setDaemon(true);

        // 启动线程
        userThread.start();
        daemonThread.start();

        // 主线程休眠 2 秒
        try {
            Thread.sleep(2000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        System.out.println("Main thread finished.");
    }
}

在这个示例中：

用户线程将休眠5秒然后输出“User thread finished.”
守护线程将每隔1秒输出“Daemon thread is running.”

主线程在启动用户线程和守护线程后，休眠2秒然后输出“Main thread finished.”并终止。当主线程和用户线程终止后，守护线程也会自动终止，尽管它在无限循环中。

线程经常用的方法有哪些

Java中的线程类Thread提供了许多常用的方法，用于线程的创建、管理和控制。以下是一些常用的线程方法及其用途：

1. `start()`

描述：启动线程，调用线程的run()方法。

示例：

Thread thread = new Thread(() -> {
    System.out.println("Thread is running.");
});
thread.start();

2. `run()`

描述：包含线程的执行代码。直接调用不会启动新线程，而是在当前线程中执行。

示例：

public class MyRunnable implements Runnable {
    public void run() {
        System.out.println("Thread is running.");
    }
}

public class Main {
    public static void main(String[] args) {
        Thread thread = new Thread(new MyRunnable());
        thread.start();  // 运行在新线程中
    }
}

3. `sleep(long millis)`

描述：使当前线程休眠指定的毫秒数。

示例：

try {
    Thread.sleep(1000);  // 当前线程休眠1秒
} catch (InterruptedException e) {
    e.printStackTrace();
}

4. `join()`

描述：等待线程终止。可以指定等待时间，默认无限期等待。

示例：

Thread thread = new Thread(() -> {
    System.out.println("Thread is running.");
});
thread.start();

try {
    thread.join();  // 等待线程结束
} catch (InterruptedException e) {
    e.printStackTrace();
}

5. `interrupt()`

描述：中断线程，设置线程的中断状态。

示例：

Thread thread = new Thread(() -> {
    while (!Thread.currentThread().isInterrupted()) {
        System.out.println("Thread is running.");
    }
});
thread.start();

thread.interrupt();  // 中断线程

6. `isInterrupted()`

描述：检查线程是否被中断，不会清除中断状态。

示例：

Thread thread = new Thread(() -> {
    while (!Thread.currentThread().isInterrupted()) {
        System.out.println("Thread is running.");
    }
});
thread.start();

thread.interrupt();
System.out.println(thread.isInterrupted());  // 输出 true

7. `setDaemon(boolean on)`

描述：将线程设置为守护线程，必须在调用start()方法之前设置。

示例：

Thread thread = new Thread(() -> {
    while (true) {
        System.out.println("Daemon thread is running.");
    }
});
thread.setDaemon(true);
thread.start();

8. `getId()`

描述：获取线程的唯一标识符。

示例：

Thread thread = new Thread(() -> {
    System.out.println("Thread ID: " + Thread.currentThread().getId());
});
thread.start();

9. `getName()` 和 `setName(String name)`

描述：获取或设置线程的名称。

示例：

Thread thread = new Thread(() -> {
    System.out.println("Thread Name: " + Thread.currentThread().getName());
});
thread.setName("MyThread");
thread.start();

10. `getPriority()` 和 `setPriority(int newPriority)`

描述：获取或设置线程的优先级。优先级范围从Thread.MIN_PRIORITY (1) 到 Thread.MAX_PRIORITY (10)。

示例：

Thread thread = new Thread(() -> {
    System.out.println("Thread Priority: " + Thread.currentThread().getPriority());
});
thread.setPriority(Thread.MAX_PRIORITY);
thread.start();

11. `currentThread()`

描述：静态方法，返回当前正在执行的线程对象。

示例：

Thread thread = new Thread(() -> {
    System.out.println("Current Thread: " + Thread.currentThread().getName());
});
thread.start();

12. `yield()`

描述：提示调度器当前线程愿意让出CPU，但不保证会让出。适用于调试和调度控制。

示例：

Thread thread = new Thread(() -> {
    System.out.println("Thread yielding.");
    Thread.yield();
});
thread.start();

这些方法提供了线程控制和管理的基本功能，根据具体需求选择合适的方法，可以更好地管理多线程程序。

start 和 run 方法有什么区别？

在Java中，start()和run()方法是用于线程管理的重要方法。虽然它们都与线程执行相关，但它们的作用和行为有显著区别。

start()方法：
- 启动一个新线程。
- 新线程中执行run()方法。
- 实现并发执行。
run()方法：
- 定义线程要执行的代码。
- 直接调用时不创建新线程，在当前线程中执行。
- 通过start()方法间接调用时，在新线程中执行。

正确使用start()方法来启动线程，以确保代码在新线程中并发执行。直接调用run()方法只会在当前线程中执行，无法实现并发。

`start()` 方法

作用：启动一个新线程。
内部机制：start()方法会创建一个新的线程，并调用线程的run()方法。在新线程中运行代码。
并发：调用start()方法后，新的线程将与主线程并发运行。主线程不会等待新的线程完成后才继续执行。

示例：

class MyThread extends Thread {
    public void run() {
        System.out.println("Thread is running.");
    }
}

public class Main {
    public static void main(String[] args) {
        MyThread thread = new MyThread();
        thread.start();  // 启动新线程，run()方法在新线程中执行
        System.out.println("Main thread is running.");
    }
}

输出可能是：

Main thread is running.
Thread is running.

`run()` 方法

作用：定义线程要执行的代码。
调用方式：
- 直接调用：直接调用run()方法不会创建新线程，它将在当前线程中运行。
- 通过start()调用：start()方法内部会调用run()方法，但在新线程中执行。
并发：直接调用run()方法不会产生并发行为，代码将在调用线程中顺序执行。

示例：

class MyThread extends Thread {
    public void run() {
        System.out.println("Thread is running.");
    }
}

public class Main {
    public static void main(String[] args) {
        MyThread thread = new MyThread();
        thread.run();  // run()方法在主线程中执行
        System.out.println("Main thread is running.");
    }
}

输出将是：

Thread is running.
Main thread is running.

wait 方法和 sleep 方法有什么区别？

wait 方法和 sleep 方法都是用于暂停线程执行的手段，但它们有不同的用途和行为。

锁的释放：
- sleep：线程暂停执行但不释放锁。
- wait：线程暂停执行并释放锁。
归属类：
- sleep：属于 Thread 类。
- wait：属于 Object 类。
用途：
- sleep：用于暂停线程执行一段固定的时间。
- wait：用于线程间的通信，等待某个条件发生变化。
唤醒方式：
- sleep：时间到期后自动唤醒。
- wait：必须被其他线程通过 notify 或 notifyAll 唤醒。

`sleep` 方法

定义：sleep 方法是属于 Thread 类或者通过 Thread 类的静态方法调用。
作用：sleep 方法用于将当前线程暂停一段时间。这段时间是由方法参数指定的。
锁机制：sleep 方法不会释放锁。也就是说，如果线程在持有锁的时候调用 sleep，其他线程无法访问这个锁。
常用场景：sleep 方法通常用于在需要暂停执行某段代码一段时间时。

示例代码：

try {
    Thread.sleep(1000);  // 当前线程暂停1秒
} catch (InterruptedException e) {
    e.printStackTrace();
}

`wait` 方法

定义：wait 方法是属于 Object 类。每个对象都能调用这个方法。
作用：wait 方法用于让调用该方法的线程进入等待状态，直到其他线程调用相同对象的 notify 或 notifyAll 方法。
锁机制：wait 方法会释放对象的锁。这意味着其他线程可以获得该锁并修改对象的状态。
常用场景：wait 方法通常用于线程间的通信，即一个线程等待另一个线程完成某项工作或满足某个条件。

示例代码：

synchronized (sharedObject) {
    try {
        sharedObject.wait();  // 当前线程进入等待状态，释放锁
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
}

// 在其他线程中
synchronized (sharedObject) {
    sharedObject.notify();  // 唤醒在 sharedObject 上等待的线程
}

说一下线程的生命周期？

线程的生命周期通常包括以下几个状态：新建（New）、就绪（Runnable）、运行（Running）、阻塞（Blocked）、等待（Waiting）、定时等待（Timed Waiting）和终止（Terminated）。这些状态描述了线程从创建到销毁的整个过程。

状态转换图

新建 -> 就绪：调用 start() 方法。
就绪 -> 运行：线程调度器选中该线程。
运行 -> 阻塞：线程试图获取一个锁，而该锁被其他线程持有。
运行 -> 等待/定时等待：调用 wait(), sleep(long), join(long) 等方法。
等待/定时等待 -> 就绪：调用 notify(), notifyAll(), 时间到期 等。
运行 -> 终止：线程运行结束或抛出未捕获的异常。
阻塞 -> 就绪：线程获取到锁。

了解线程的生命周期对于编写和调试多线程程序非常重要，能够帮助开发者更好地管理线程及其状态转换。

下面是对每个状态的详细解释：

1. 新建 (New)

线程对象已经创建，但还没有调用 start() 方法。此时线程还没有开始执行。

Thread thread = new Thread();

2. 就绪 (Runnable)

当调用 start() 方法后，线程进入就绪状态。此时，线程已经被 JVM 识别，可以运行了，但还没有被调度器选中开始执行。

thread.start();

3. 运行 (Running)

线程调度器从就绪状态中选择一个线程并开始执行其 run() 方法。一个线程只能在一种状态下运行。

4. 阻塞 (Blocked)

线程在等待一个监视器锁，以便进入一个同步块/方法。这通常发生在等待进入一个同步块/方法的线程未能获取锁时。

synchronized (someObject) {
    // some synchronized code
}

5. 等待 (Waiting)

线程等待另一个线程显式地唤醒它。线程进入这种状态是通过调用以下方法之一：

Object.wait() 方法（无超时）
Thread.join() 方法（无超时）
LockSupport.park() 方法

synchronized (someObject) {
    someObject.wait();
}

6. 定时等待 (Timed Waiting)

线程等待一段时间后将自动唤醒。线程进入这种状态是通过调用以下方法之一：

Thread.sleep(long millis)
Object.wait(long timeout)
Thread.join(long millis)
LockSupport.parkNanos(long nanos)
LockSupport.parkUntil(long deadline)

try {
    Thread.sleep(1000);  // 睡眠1秒
} catch (InterruptedException e) {
    e.printStackTrace();
}

7. 终止 (Terminated)

线程已经完成执行或者因异常退出了 run() 方法。此时线程生命周期结束。

public void run() {
    // 线程执行的任务
}

说一下Object.wait()和Thread.join()之间的区别

Object.wait() 和 Thread.join() 都是用于线程同步和协调的方法，但它们的用途和工作方式有所不同。以下是它们之间的主要区别：

所属类：
- wait()：属于 Object 类。
- join()：属于 Thread 类。
用途：
- wait()：用于线程间通信，当前线程等待某个条件。
- join()：当前线程等待目标线程完成。
使用场景：
- wait()：通常在同步块/方法中使用，用于等待条件变化并释放锁。
- join()：不需要同步块/方法，直接等待目标线程完成。
锁机制：
- wait()：必须在持有对象监视器锁的同步块/方法中调用，调用后会释放锁。
- join()：不涉及锁的释放和获取。
唤醒机制：
- wait()：需要其他线程调用 notify() 或 notifyAll() 方法来唤醒。
- join()：目标线程结束时，自动唤醒等待线程。

`Object.wait()`

定义和用法

所属类：Object 类。
用途：使当前线程等待，直到其他线程调用该对象的 notify() 或 notifyAll() 方法。
锁机制：必须在同步块或同步方法中使用，即调用 wait() 方法的线程必须持有该对象的监视器锁。当调用 wait() 方法时，线程会释放锁并进入等待状态，直到被唤醒。

示例代码

synchronized (someObject) {
    try {
        someObject.wait();  // 当前线程进入等待状态，并释放锁
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
}

适用场景

线程间通信：通常用于实现线程间的等待/通知机制，一个线程等待某个条件成立，而另一个线程通知条件的变化。
锁的释放：wait() 方法会释放对象的监视器锁，使得其他线程可以获取该锁并进行相应的处理。

`Thread.join()`

定义和用法

所属类：Thread 类。
用途：使当前线程等待，直到目标线程完成，即当前线程会等待目标线程终止。
锁机制：不需要在同步块或同步方法中使用。调用 join() 方法的线程只是等待目标线程完成，并不涉及锁的释放和获取。

示例代码

Thread thread = new Thread(() -> {
    // 线程执行的任务
});
thread.start();
try {
    thread.join();  // 当前线程等待目标线程结束
} catch (InterruptedException e) {
    e.printStackTrace();
}

适用场景

线程协作：通常用于等待某个线程完成，以便后续操作能够在目标线程完成后进行。比如，一个线程需要等待其他线程完成某些初始化操作。
无需同步块：join() 方法不需要在同步块或同步方法中使用。

怎么终止线程？

终止线程是多线程编程中的一个重要问题，确保线程能够干净、安全地结束非常重要。

最推荐的方法是使用中断机制或标志变量来控制线程的终止，这样可以确保线程能够安全、干净地结束，并且能够进行必要的清理工作。使用 Future 和 ExecutorService 也是一种较为现代和安全的方式来管理线程的生命周期。

以下是几种终止线程的常见方法：

1. 使用线程的中断机制

中断机制是最常见和推荐的方法，通过设置线程的中断标志，让线程自行决定何时检查并终止。

示例代码

class MyRunnable implements Runnable {
    @Override
    public void run() {
        while (!Thread.currentThread().isInterrupted()) {
            try {
                // 执行线程任务
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                // 捕获中断异常并设置中断状态
                Thread.currentThread().interrupt();
                break;
            }
        }
        // 进行资源清理等操作
    }
}

Thread thread = new Thread(new MyRunnable());
thread.start();

// 终止线程
thread.interrupt();

解释

检查中断状态：通过 Thread.currentThread().isInterrupted() 检查线程是否被中断。
处理中断异常：在 catch 块中重新设置中断状态，并通过 break 跳出循环。

2. 使用一个标志变量

通过一个共享的标志变量来控制线程的运行。这种方法需要确保标志变量是线程安全的（例如，使用 volatile 关键字）。

示例代码

class MyRunnable implements Runnable {
    private volatile boolean running = true;

    @Override
    public void run() {
        while (running) {
            // 执行线程任务
        }
        // 进行资源清理等操作
    }

    public void stop() {
        running = false;
    }
}

MyRunnable runnable = new MyRunnable();
Thread thread = new Thread(runnable);
thread.start();

// 终止线程
runnable.stop();

解释

标志变量：running 是一个 volatile 变量，用于控制线程的运行。
终止线程：调用 runnable.stop() 方法将 running 变量设置为 false，使线程跳出循环并终止。

3. 使用 `Future` 和 `ExecutorService`

如果使用 ExecutorService 来管理线程，可以通过 Future 对象来取消任务。

示例代码

ExecutorService executor = Executors.newSingleThreadExecutor();
Future<?> future = executor.submit(() -> {
    while (!Thread.currentThread().isInterrupted()) {
        // 执行线程任务
    }
    // 进行资源清理等操作
});

// 终止线程
future.cancel(true);
executor.shutdown();

解释

取消任务：通过 future.cancel(true) 方法取消任务，并中断正在执行的线程。
关闭线程池：通过 executor.shutdown() 关闭线程池。

4. 使用 `Thread.stop()` 方法（不推荐）

Thread.stop() 方法已经过时且不推荐使用，因为它会强制终止线程，不会释放线程持有的锁，可能导致不一致状态和死锁。

示例代码（仅供了解，不推荐使用）

Thread thread = new Thread(() -> {
    while (true) {
        // 执行线程任务
    }
});
thread.start();

// 强制终止线程（不推荐）
thread.stop();

解释

风险：强制终止线程，可能会导致资源没有正确释放、数据损坏或其他不一致问题。

介绍一下volatile关键字

volatile 关键字在 Java 中是用于保证变量的可见性和有序性的关键字。它通常用于在多线程环境下解决线程间变量的可见性问题，是一个轻量级的同步机制，用于确保变量的可见性和有序性，但不保证操作的原子性。它适用于一些简单的状态标志和单次写入、多次读取的场景。在使用 volatile 时，需要了解它的局限性，并在必要时结合其他同步机制来保证线程安全。

以下是对 volatile 关键字的详细介绍：

1. 可见性

在多线程环境中，每个线程都有自己的缓存，当一个线程修改了某个变量的值后，其他线程可能不会立即看到这个修改。volatile 关键字*可以保证所有线程对这个变量的访问都是从主内存中读取的，而不是从线程的本地缓存读取。*这样，当一个线程修改了 volatile 变量的值后，其他线程立即可以看到这个变化。

示例代码

public class VolatileExample {
    private volatile boolean flag = false;

    public void writer() {
        flag = true; // 修改volatile变量
    }

    public void reader() {
        if (flag) {
            // 读取volatile变量，保证能看到最新值
            System.out.println("Flag is true");
        }
    }
}

在这个示例中，当一个线程调用 writer() 方法将 flag 设置为 true 后，另一个线程调用 reader() 方法时，一定会看到 flag 的最新值。

2. 有序性

volatile 关键字还可以防止指令重排序。Java 编译器和处理器为了优化性能，可能会对指令进行重排序，但这种重排序不会影响单线程环境下的结果。然而，在多线程环境下，这可能会导致意外的行为。使用 volatile 可以禁止指令重排序，从而确保程序执行的顺序是预期的。

示例代码

public class VolatileReorderingExample {
    private volatile boolean flag = false;
    private int a = 0;

    public void writer() {
        a = 1;          // 语句1
        flag = true;    // 语句2
    }

    public void reader() {
        if (flag) {     // 语句3
            // 由于flag是volatile变量，语句3不会重排序到语句1之前
            System.out.println("a = " + a); // 语句4
        }
    }
}

在这个示例中，flag 是一个 volatile 变量。由于 volatile 禁止重排序，语句2不会在语句1之前执行，同样，语句3不会在语句1之前执行。

3. 适用场景

volatile 关键字通常适用于以下场景：

状态标志：用于指示某个状态变化的标志，如程序是否终止、任务是否完成等。
单次写入、多次读取：某个变量只在一个线程中被写入，但在多个线程中被读取。
简单同步：不涉及复杂的同步机制，只是需要保证某个变量的可见性和有序性。

4. 注意事项

不保证原子性：volatile 关键字仅保证可见性和有序性，不保证操作的原子性。例如，对于 volatile int 变量的自增操作 i++，依然是非原子的，需要使用 synchronized 或 AtomicInteger 来保证原子性。
不能替代 synchronized：volatile 关键字不能替代 synchronized 关键字，不能用于需要保证多个变量之间一致性的场景。

示例代码：非原子性问题

public class VolatileAtomicityExample {
    private volatile int count = 0;

    public void increment() {
        count++;  // 非原子操作
    }
}

在这个示例中，count++ 是一个非原子操作，尽管 count 是 volatile 变量，多个线程同时执行 increment() 方法时，仍然可能导致计数错误。

说一下Object.wait()和Thread.join()之间的区别

Object.wait() 和 Thread.join() 是 Java 中用于线程同步的两种方法，但它们的用途和实现机制有所不同。

Object.wait() 是用于线程间通信和协作的机制，需要在同步块或同步方法中使用，通过 notify() 或 notifyAll() 唤醒等待线程。
Thread.join() 是用于等待特定线程完成的机制，不需要在同步块中使用，当前线程将等待被调用线程终止后继续执行。

Object.wait()

用途: wait() 方法用于线程间的通信。它使当前线程进入等待状态，直到其他线程调用同一对象的 notify() 或 notifyAll() 方法来唤醒它。
调用者: wait() 方法必须在同步块或同步方法中调用（即，线程必须持有该对象的监视器锁）。
原理: 当线程调用 wait() 方法时，它会释放对象的监视器锁并进入等待队列，直到其他线程对该对象调用 notify() 或 notifyAll() 方法来通知等待的线程。被唤醒的线程会重新竞争对象的监视器锁。
例子:

synchronized (sharedObject) {
    while (conditionNotMet) {
        sharedObject.wait();
    }
    // 继续执行
}

Thread.join()

用途: join() 方法用于等待另一个线程完成执行。当前线程调用另一个线程的 join() 方法，将等待该线程终止后才继续执行。
调用者: join() 方法在任何线程中都可以调用，不需要在同步块中调用。
原理: 当线程调用另一个线程的 join() 方法时，当前线程会进入等待状态，直到被调用线程完成（即该线程终止）。当前线程会继续执行。
例子:

Thread t = new Thread(() -> {
    // 线程t的任务
});
t.start();
t.join(); // 当前线程等待线程t执行完毕
// 继续执行

时常在面试中被问到的多线程问题：上篇

文章目录

进程和线程有什么区别？

定义

内存空间

资源开销

通信方式

独立性

适用场景

多线程有什么优缺点？

优点

缺点

线程的创建方式有哪些？

1. 继承Thread类

2. 实现Runnable接口

3. 使用匿名内部类

4. 使用Lambda表达式（Java 8及以上）

5. 使用Executor框架

如何简单的使用线程？

方法1：继承Thread类

示例代码：

方法2：实现Runnable接口

示例代码：

使用Lambda表达式（Java 8及以上）

示例代码：

用户线程和守护线程有什么区别？

用户线程（User Thread）

守护线程（Daemon Thread）

示例代码

线程经常用的方法有哪些

1. start()

2. run()

3. sleep(long millis)

4. join()

5. interrupt()

6. isInterrupted()

7. setDaemon(boolean on)

8. getId()

9. getName() 和 setName(String name)

10. getPriority() 和 setPriority(int newPriority)

11. currentThread()

12. yield()

start 和 run 方法有什么区别？

start() 方法

run() 方法

wait 方法和 sleep 方法有什么区别？

sleep 方法

wait 方法

说一下线程的生命周期？

状态转换图

1. 新建 (New)

2. 就绪 (Runnable)

3. 运行 (Running)

4. 阻塞 (Blocked)

5. 等待 (Waiting)

6. 定时等待 (Timed Waiting)

7. 终止 (Terminated)

说一下Object.wait()和Thread.join()之间的区别

Object.wait()

定义和用法

示例代码

适用场景

Thread.join()

定义和用法

示例代码

适用场景

怎么终止线程？

1. 使用线程的中断机制

示例代码

解释

2. 使用一个标志变量

示例代码

解释

3. 使用 Future 和 ExecutorService

示例代码

解释

4. 使用 Thread.stop() 方法（不推荐）

示例代码（仅供了解，不推荐使用）

解释

介绍一下volatile关键字

1. `start()`

2. `run()`

3. `sleep(long millis)`

4. `join()`

5. `interrupt()`

6. `isInterrupted()`

7. `setDaemon(boolean on)`

8. `getId()`

9. `getName()` 和 `setName(String name)`

10. `getPriority()` 和 `setPriority(int newPriority)`

11. `currentThread()`

12. `yield()`

`start()` 方法

`run()` 方法

`sleep` 方法

`wait` 方法

`Object.wait()`

`Thread.join()`

3. 使用 `Future` 和 `ExecutorService`

4. 使用 `Thread.stop()` 方法（不推荐）