【Java寻宝之旅】线程

Java中的线程

继承Thread类创建线程

实现Runnable接口创建线程

Callable和Future

线程的生命周期

Java 线程的生命周期

创建与启动线程

线程的状态转换

线程的优先级

前言

在计算机科学领域，线程是指在一个进程内部执行的独立单元。一个进程可以包含多个线程，每个线程都有自己的执行路径，可以独立运行。线程是操作系统进行任务调度和分配的基本单位，它允许我们实现并发执行，使得程序能够更高效地利用计算机资源。

Java中的线程

Java是一门多线程编程语言，它内置了多线程支持的类库和API，使得开发人员可以轻松地创建和管理线程。在Java中，线程是通过java.lang.Thread类来表示的。您可以通过继承Thread类或实现Runnable接口来创建线程。

继承Thread类创建线程

要创建一个线程，您可以继承Thread类，并重写run()方法来定义线程的执行逻辑。以下是一个简单的示例：

class MyThread extends Thread {
    public void run() {
        // 线程的执行逻辑
        for (int i = 0; i < 10; i++) {
            System.out.println("Thread: " + i);
        }
    }
}

然后，您可以创建线程对象并调用start()方法来启动线程： 

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

实现Runnable接口创建线程

除了继承Thread类，您还可以通过实现Runnable接口来创建线程。这种方式更加灵活，因为一个类可以同时实现多个接口。以下是示例代码：

class MyRunnable implements Runnable {
    public void run() {
        // 线程的执行逻辑
        for (int i = 0; i < 10; i++) {
            System.out.println("Runnable: " + i);
        }
    }
}

然后，您需要将Runnable对象传递给Thread类的构造函数，并调用start()方法启动线程： 

public class Main {
    public static void main(String[] args) {
        MyRunnable myRunnable = new MyRunnable();
        Thread thread = new Thread(myRunnable); // 创建线程并传入Runnable对象
        thread.start(); // 启动线程
    }
}

Callable和Future

除了上述两种方式，还可以使用Callable和Future来创建线程，这是一种更高级的方法，允许线程执行完毕后返回结果。这在需要获取线程执行结果时非常有用。

import java.util.concurrent.Callable;
import java.util.concurrent.FutureTask;

class MyCallable implements Callable<Integer> {
    public Integer call() {
        int sum = 0;
        for (int i = 1; i <= 10; i++) {
            sum += i;
        }
        return sum;
    }
}

public class Main {
    public static void main(String[] args) throws Exception {
        MyCallable myCallable = new MyCallable();
        FutureTask<Integer> futureTask = new FutureTask<>(myCallable);

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

        int result = futureTask.get(); // 获取线程执行结果
        System.out.println("线程执行结果：" + result);
    }
}

线程的生命周期

一个线程在其生命周期内会经历不同的状态。理解线程的生命周期有助于我们更好地管理和控制线程的行为。Java中的线程可以处于以下几种状态：

1. 新建状态（New）： 当线程对象被创建但尚未启动时，线程处于新建状态。
2. 就绪状态（Runnable）： 当线程获得CPU时间片并执行时，线程处于就绪状态。
3. 阻塞状态（Blocked）： 当线程在等待某个条件的时候，会进入阻塞状态，直到条件满足。
4. 终止状态（Terminated）： 线程执行完任务或发生异常后，线程处于终止状态，不再执行。

在接下来的部分，我们将深入探讨线程的创建与启动。

Java 线程的生命周期

一个Java线程可以处于以下几种状态：

1. 新建状态（New）： 当线程对象被创建但尚未启动时，线程处于新建状态。
2. 就绪状态（Runnable）： 当线程获得CPU时间片并执行时，线程处于就绪状态。
3. 运行状态（Running）： 当线程获得CPU时间片并执行时，线程处于运行状态。
4. 阻塞状态（Blocked）： 当线程在等待某个条件的时候，会进入阻塞状态，直到条件满足。
5. 等待状态（Waiting）： 当线程等待某个条件的时候，会进入等待状态，直到条件满足。
6. 超时等待状态（Timed Waiting）： 当线程等待某个条件的时候，可以设置一个超时时间，超过这个时间后线程会进入超时等待状态。
7. 终止状态（Terminated）： 线程执行完任务或发生异常后，线程处于终止状态，不再执行。

了解线程的生命周期对于编写多线程程序非常重要，因为我们需要根据线程的状态来进行合适的操作和控制。

创建与启动线程

在Java中，有两种常见的方式来创建和启动线程：

1. 继承Thread类： 您可以创建一个继承自Thread类的子类，并重写run()方法来定义线程的执行逻辑。然后，创建线程对象并调用start()方法来启动线程。
2. 实现Runnable接口： 您可以创建一个实现Runnable接口的类，并重写run()方法来定义线程的执行逻辑。然后，创建线程对象，并将Runnable对象传递给线程的构造函数，并调用start()方法来启动线程。

下面是两种方式的示例代码：

// 继承Thread类创建线程
class MyThread extends Thread {
    public void run() {
        // 线程的执行逻辑
        for (int i = 0; i < 10; i++) {
            System.out.println("Thread: " + i);
        }
    }
}

// 实现Runnable接口创建线程
class MyRunnable implements Runnable {
    public void run() {
        // 线程的执行逻辑
        for (int i = 0; i < 10; i++) {
            System.out.println("Runnable: " + i);
        }
    }
}

public class Main {
    public static void main(String[] args) {
        // 创建并启动继承Thread类的线程
        MyThread myThread = new MyThread();
        myThread.start();

        // 创建并启动实现Runnable接口的线程
        MyRunnable myRunnable = new MyRunnable();
        Thread thread = new Thread(myRunnable);
        thread.start();
    }
}

线程的状态转换

一个线程在其生命周期内会经历不同的状态，这些状态之间可以相互转换。以下是线程可能的状态转换：

1. 新建（New） -> 就绪（Runnable）： 当线程对象被创建后，线程处于新建状态，但尚未启动。通过调用start()方法，线程将转换为就绪状态。
2. 就绪（Runnable） -> 运行（Running）： 当线程获得CPU时间片并开始执行时，线程从就绪状态转换为运行状态。
3. 运行（Running） -> 就绪（Runnable）： 当线程的时间片用完，或者主动调用yield()方法，线程将从运行状态转换为就绪状态。
4. 运行（Running） -> 阻塞（Blocked）： 当线程在等待某个条件时，例如等待I/O操作完成，线程将从运行状态转换为阻塞状态。
5. 运行（Running） -> 终止（Terminated）： 当线程的run()方法执行完毕，线程将从运行状态转换为终止状态。
6. 就绪（Runnable） -> 终止（Terminated）： 当线程的run()方法执行完毕，线程将从就绪状态直接转换为终止状态。
7. 阻塞（Blocked） -> 就绪（Runnable）： 当线程等待的条件满足时，线程将从阻塞状态转换为就绪状态。
8. 阻塞（Blocked） -> 终止（Terminated）： 当线程等待的条件不再满足，或者等待超时，线程将从阻塞状态转换为终止状态。
9. 等待（Waiting） -> 就绪（Runnable）： 当线程等待的条件满足时，线程将从等待状态转换为就绪状态。
10. 等待（Waiting） -> 终止（Terminated）： 当线程等待的条件不再满足，或者等待超时，线程将从等待状态转换为终止状态。
11. 超时等待（Timed Waiting） -> 就绪（Runnable）： 当线程等待的条件满足时，线程将从超时等待状态转换为就绪状态。
12. 超时等待（Timed Waiting） -> 终止（Terminated）： 当线程等待的条件不再满足，或者等待超时，线程将从超时等待状态转换为终止状态。

理解这些状态的转换非常重要，因为我们需要根据线程的当前状态来决定如何操作线程，以实现我们想要的并发行为。

线程的优先级

Java线程可以具有不同的优先级，用于告诉操作系统在竞争CPU时间片时应该优先考虑哪个线程。线程的优先级范围从1到10，默认优先级是5。您可以使用setPriority()方法设置线程的优先级，范围从1（最低优先级）到10（最高优先级）。

Thread thread = new Thread();
thread.setPriority(8); // 设置线程优先级为8

请注意，线程的优先级只是一个建议，操作系统可以选择是否遵守它。因此，不要过分依赖线程优先级来控制程序的行为。