线程是什么
线程是操作系统中调度的基本单位，是比进程更小的执行单元。线程在进程内部运行，共享该进程的资源，如内存和文件句柄，但每个线程都有自己的执行栈和程序计数器。
线程的主要特点包括：
轻量级：线程相较于进程更加轻量，创建和销毁的开销较小。共享资源：同一进程中的线程共享该进程的内存空间和资源，从而可以更高效地进行数据交换。并发执行：多个线程可以并发执行，充分利用多核处理器，提高程序的执行效率。简化管理：线程的切换和管理相对于进程更为简单和迅速，有助于提升系统的响应速度。线程的使用在现代操作系统中非常普遍，尤其是在需要高并发和高性能的应用场景中，例如网络服务器和多任务应用程序等。
为什么要有线程
首先, "并发编程" 成为 "刚需"。
单核 CPU 的发展遇到了瓶颈. 要想提高算力, 就需要多核 CPU. 而并发编程能更充分利用多核 CPU资源。
有些任务场景需要 "等待 IO", 为了让等待 IO 的时间能够去做一些其他的工作, 也需要用到并发编
程。
其次, 虽然多进程也能实现 并发编程, 但是线程比进程更轻量。
创建线程比创建进程更快.销毁线程比销毁进程更快.调度线程比调度进程更快.
创建出一个线程
在Java中，可以通过两种主要方式创建线程：继承Thread类和实现Runnable接口。下面分别介绍这两种方式，并附上代码示例。
方法一：继承 Thread 类
创建一个子类，继承Thread类，并重写run()方法，该方法包含了线程的执行代码。创建子类的实例，然后调用start()方法来启动线程。 示例代码：
class MyThread extends Thread { @Override public void run() { // 线程执行的代码 for (int i = 0; i < 5; i++) { System.out.println("Thread running: " + i); try { Thread.sleep(1000); // 暂停1秒 } catch (InterruptedException e) { e.printStackTrace(); } } }}public class ThreadExample { public static void main(String[] args) { Thread thread = new MyThread(); // 创建线程对象 thread.start(); // 启动线程 }}
方法二：实现 Runnable 接口
创建一个类，实现Runnable接口，并实现run()方法。创建Runnable接口的实例，将其传递给Thread构造函数，然后调用start()方法启动线程。 示例代码：
class MyRunnable implements Runnable { @Override public void run() { // 线程执行的代码 for (int i = 0; i < 5; i++) { System.out.println("Runnable thread running: " + i); try { Thread.sleep(1000); // 暂停1秒 } catch (InterruptedException e) { e.printStackTrace(); } } }}public class RunnableExample { public static void main(String[] args) { MyRunnable myRunnable = new MyRunnable(); // 创建Runnable实例 Thread thread = new Thread(myRunnable); // 将Runnable实例传递给Thread thread.start(); // 启动线程 }}解析：
在这两个示例中，我们创建了一个简单的线程，该线程在运行时每秒打印一次数字（0到4）。使用Thread.sleep(1000)使线程暂停1秒，这样可以模拟一些耗时的操作，也使得输出不至于淹没在快速的执行中。调用start()方法时，Java虚拟机会调用线程的run()方法，而不是直接调用run()。这保证了线程的正确启动和管理。 总结：
通过这两种方式，Java允许灵活地创建和管理线程，开发者可以根据具体需求选择适合的方式。继承Thread类比较直接，但实现Runnable接口则可以实现更灵活的线程管理和资源共享。
引入匿名内部类和 Lambda 简化上述方法
匿名内部类
方法一
public class ThreadExample { public static void main(String[] args) { Thread thread = new Thread() { // 线程执行的代码 @Override public void run() { // 线程执行的代码 for (int i = 0; i < 5; i++) { System.out.println("Runnable thread running: " + i); try { Thread.sleep(1000); // 暂停1秒 } catch (InterruptedException e) { e.printStackTrace(); } } } }; thread.start(); }}方法二
public class ThreadExample { public static void main(String[] args) { Thread thread = new Thread(new Runnable() { @Override public void run() { // 线程执行的代码 for (int i = 0; i < 5; i++) { System.out.println("Runnable thread running: " + i); try { Thread.sleep(1000); // 暂停1秒 } catch (InterruptedException e) { e.printStackTrace(); } } } }); thread.start(); }}Lambda 表达式
public class ThreadExample { public static void main(String[] args) { Thread thread = new Thread(() -> { // 线程执行的代码 for (int i = 0; i < 5; i++) { System.out.println("Runnable thread running: " + i); try { Thread.sleep(1000); // 暂停1秒 } catch (InterruptedException e) { e.printStackTrace(); } } }); thread.start(); }}Lambda 表达式由于简洁，所以是日常开发中常用的方法。
查看线程
当我们创建好一个线程后如何查看线程的状态呢？
使用 jconsole 命令观察线程
我们打开 jdk 文件夹所在目录，找到 bin 文件夹。
找到 jconsole.exe 双击打开。
选择我们的类名的选项，点击连接。
连接好了后，选择线程，然后找到 Thread-0 这个就是我们手动创建的线程，我们可以查看该线程的运行情况。
Thread 中常见的方法
Thread类是Java中用于创建和管理线程的重要类，提供了多种方法来控制线程的行为和状态。以下是一些常见的Thread类方法：
**start()**：启动线程，JVM会调用线程的run()方法。
**run()**：线程执行的代码逻辑所在的方法。可以被重写来定义线程的任务。
**sleep(long millis)**：使当前线程暂停指定的时间（毫秒），在此期间线程不会执行。
**join()**：等待调用该方法的线程完成后再继续执行。这是实现线程间的同步的一种方式。
**interrupt()**：中断线程，设置线程的中断状态。如果该线程正在阻塞（例如在sleep()或wait()中），则会抛出InterruptedException。
**isAlive()**：判断线程是否仍在运行中，返回true表示线程处于活动状态。
**getName()**：返回线程的名称。
**setName(String name)**：设置线程的名称。
**getPriority()**：返回线程的优先级。
**setPriority(int priority)**：设置线程的优先级，优先级范围为Thread.MIN_PRIORITY（1）到Thread.MAX_PRIORITY（10）。
**yield()**：提示调度器当前线程愿意让出对 CPU 的占用，由其他同等或更高优先级的线程获得执行机会。
**currentThread()**：静态方法，返回对当前正在执行的线程对象的引用。
示例：
以下是一个简单的代码示例，演示了部分常见方法的用法：
class MyThread extends Thread { @Override public void run() { System.out.println(getName() + " is running"); try { sleep(1000); // 暂停1秒 } catch (InterruptedException e) { System.out.println(getName() + " was interrupted"); } System.out.println(getName() + " has finished running"); }}public class ThreadMethodsExample { public static void main(String[] args) { MyThread thread1 = new MyThread(); MyThread thread2 = new MyThread(); thread1.setName("Thread-1"); thread2.setName("Thread-2"); thread1.start(); thread2.start(); try { thread1.join(); // 等待thread1完成 thread2.join(); // 等待thread2完成 } catch (InterruptedException e) { e.printStackTrace(); } System.out.println("All threads have finished executing."); }}在这个示例中，我们创建了两个线程，设置了它们的名称，并演示了start()、sleep()和join()方法的使用。
如何中断一个线程
在Java中，手动中断一个线程的原理主要依赖于线程的 interrupt() 方法和线程的 isInterrupted() 状态。通过调用一个线程的 interrupt() 方法，可以设置该线程的中断状态为 true。这通常用于通知线程它应该停止当前的工作，并进行清理或其他的收尾操作。
当一个线程被中断后，如果该线程在阻塞状态（例如，等待输入、休眠等），则会抛出 InterruptedException。如果线程在其他执行状态中，通常需要在合适的位置检查该线程的中断状态，决定是否需要停止执行。
以下是一个简单的案例，展示如何手动中断一个线程：
示例代码
class MyRunnable implements Runnable { @Override public void run() { try { System.out.println("线程开始工作..."); // 模拟长时间工作的情况 for (int i = 0; i < 10; i++) { // 检查线程是否被中断 if (Thread.currentThread().isInterrupted()) { System.out.println("线程被中断，退出工作..."); return; // 退出运行 } System.out.println("工作中: " + i); // 模拟工作过程中的延时 Thread.sleep(1000); } } catch (InterruptedException e) { // 如果线程因为sleep被中断，会抛出InterruptedException System.out.println("线程被中断，捕获到异常: " + e.getMessage()); } finally { System.out.println("线程清理工作，准备结束..."); } }}public class ThreadInterruptExample { public static void main(String[] args) throws InterruptedException { Thread myThread = new Thread(new MyRunnable()); myThread.start(); // 主线程等待2秒，然后中断myThread Thread.sleep(2000); System.out.println("主线程请求中断myThread..."); myThread.interrupt(); // 中断线程 // 等待myThread结束 myThread.join(); System.out.println("主线程结束。"); }}代码解释
MyRunnable 类实现 Runnable 接口并重写 run() 方法。在 run() 方法中，模拟了一个长时间工作的循环，每次循环检查线程的中断状态。如果线程被中断，可以通过 Thread.currentThread().isInterrupted() 方法来检测，并通过返回来优雅地退出工作。在主线程中，创建并启动一个新线程，等待2秒后调用 interrupt() 方法中断它。如果在 sleep() 等待期间线程被中断，InterruptedException 将被抛出，因此可以在 catch 块中进行相应处理。最后，使用 join() 等待 myThread 完成所有操作后再结束主线程。 总结
通过这个案例，可以清晰地看到如何手动中断线程以及如何处理线程的中断状态。这种机制在多线程编程中非常重要，确保了线程可以在合适的时机响应中断请求，从而实现更好的资源管理和程序健壮性。
join 等待一个线程
在Java中，等待一个线程的原理主要依赖于 Thread 类中的 join() 方法。调用 join() 方法可以使当前线程（即调用 join() 的线程）等待另一个线程完成执行。原理是通过线程的状态管理，使得调用 join() 的线程在被调用线程执行完之前不会继续执行，确保线程之间的执行顺序。
示例代码
下面是一个简单的案例，展示如何等待一个线程的完成：
class MyRunnable implements Runnable { @Override public void run() { System.out.println("线程 " + Thread.currentThread().getName() + " 开始工作..."); try { // 模拟长时间的工作 Thread.sleep(2000); // 休眠2秒 } catch (InterruptedException e) { System.out.println("线程被中断: " + e.getMessage()); } System.out.println("线程 " + Thread.currentThread().getName() + " 工作完成。"); }}public class ThreadJoinExample { public static void main(String[] args) { Thread myThread = new Thread(new MyRunnable(), "MyThread"); myThread.start(); // 启动线程 try { System.out.println("主线程等待 " + myThread.getName() + " 完成..."); myThread.join(); // 等待 myThread 完成 } catch (InterruptedException e) { System.out.println("主线程被中断: " + e.getMessage()); } System.out.println("主线程继续执行，已等待 " + myThread.getName() + " 完成。"); }}代码解释
MyRunnable 类：实现Runnable 接口并重写 run() 方法。在 run() 方法中，我们模拟了一个长时间的工作，使用 Thread.sleep(2000) 使线程休眠 2 秒。主类 ThreadJoinExample： 创建一个新的线程 myThread，并将 MyRunnable 实例作为参数传入。启动线程 myThread，这会调用其 run() 方法。在主线程中，调用 myThread.join()，这将使主线程等待 myThread 完成执行。一旦 myThread 执行完成，主线程将继续执行，并打印出相应的信息。 总结
通过这个案例，可以看到如何使用 join() 方法来等待线程的完成。这样可以有效地控制线程的执行顺序，确保在某些操作完成后再进行后续处理。例如，在多个线程之间需要协调工作时，使用 join() 使得某些操作依赖于另一个线程的完成，可以减少潜在的竞争和数据不一致问题。这种机制在多线程编程中非常重要，特别是在任务依赖的场景下。
获取线程的状态
在Java中，线程的状态主要有以下几种：
NEW（新建）：当线程被创建但尚未开始运行时，处于此状态。RUNNABLE（可运行）：线程可以运行，也可能正在运行。这并不一定意味着线程正在执行，因为线程调度可能把该线程挂起。BLOCKED（阻塞）：线程在等待一个监视器锁时被阻塞，无法继续执行。WAITING（等待）：线程在等待另一个线程执行特定动作时进入此状态，如等待锁的释放。TIMED_WAITING（计时等待）：线程在等待特定时间段内的某个条件时进入此状态。TERMINATED（终止）：线程完成执行或因异常退出后进入此状态。如何获取线程状态
可以使用 Thread 类的 getState() 方法来获取线程的当前状态。下面是一个示例代码，展示了如何创建线程并获取其状态：
public class ThreadStateExample { public static void main(String[] args) { Thread thread = new Thread(new MyRunnable()); // 获取并打印状态：NEW System.out.println("Thread state after creation: " + thread.getState()); thread.start(); // 获取并打印状态：RUNNABLE System.out.println("Thread state after starting: " + thread.getState()); try { // 主线程等待一段时间以确保子线程有机会运行 Thread.sleep(100); } catch (InterruptedException e) { e.printStackTrace(); } // 获取并打印状态：TERMINATED System.out.println("Thread state after completion: " + thread.getState()); } static class MyRunnable implements Runnable { @Override public void run() { // 子线程正在运行 try { // 模拟一些工作 Thread.sleep(200); } catch (InterruptedException e) { e.printStackTrace(); } } }}说明
创建线程：在创建Thread 对象后，可以通过 getState() 获取其状态，初始状态为 NEW。启动线程：调用 start() 方法后，线程状态可能变为 RUNNABLE。等待：主线程通过 sleep() 方法等待，使子线程有机会执行。观察状态：通过 getState() 方法可以随时获取线程的状态。 这种方式能够有效地跟踪线程的状态变化，以便在多线程编程中进行调试和控制。