JAVA面试中，面试官最爱问的问题。

什么是线程？如何创建线程？

### 线程的定义

线程（Thread）是程序执行的最小单位。一个程序至少有一个进程，一个进程可以包含多个线程。线程是操作系统能够进行运算调度的基本单位。线程在同一进程中运行，共享进程的资源，如内存、文件句柄等，但每个线程有自己的栈和寄存器。

### 在Java中创建线程的两种主要方式

1. **继承Thread类**：
   - 通过继承`java.lang.Thread`类并重写`run()`方法来定义线程的任务。
   - 创建线程对象并调用`start()`方法启动线程。

2. **实现Runnable接口**：
   - 通过实现`java.lang.Runnable`接口并实现`run()`方法来定义线程的任务。
   - 创建`Thread`对象并传入`Runnable`实现对象，调用`start()`方法启动线程。

### 方式一：继承Thread类

#### 示例代码：

```java
// 定义一个继承Thread类的线程类
class MyThread extends Thread {
    @Override
    public void run() {
        // 线程任务
        for (int i = 0; i < 5; i++) {
            System.out.println(Thread.currentThread().getName() + " - " + i);
            try {
                Thread.sleep(1000); // 休眠1秒
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

public class ThreadExample {
    public static void main(String[] args) {
        // 创建线程对象
        MyThread thread1 = new MyThread();
        MyThread thread2 = new MyThread();

        // 启动线程
        thread1.start();
        thread2.start();
    }
}
```

### 方式二：实现Runnable接口

#### 示例代码：

```java
// 定义一个实现Runnable接口的线程类
class MyRunnable implements Runnable {
    @Override
    public void run() {
        // 线程任务
        for (int i = 0; i < 5; i++) {
            System.out.println(Thread.currentThread().getName() + " - " + i);
            try {
                Thread.sleep(1000); // 休眠1秒
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

public class RunnableExample {
    public static void main(String[] args) {
        // 创建Runnable实现对象
        MyRunnable myRunnable = new MyRunnable();

        // 创建Thread对象并传入Runnable实现对象
        Thread thread1 = new Thread(myRunnable);
        Thread thread2 = new Thread(myRunnable);

        // 启动线程
        thread1.start();
        thread2.start();
    }
}
```

### 比较两种方式

- **继承Thread类**：
  - 优点：代码简洁，直接定义线程任务。
  - 缺点：由于Java只支持单继承，继承`Thread`类后无法再继承其他类。

- **实现Runnable接口**：
  - 优点：更灵活，可以实现多重继承。线程任务和线程控制分离，更符合面向对象设计原则。
  - 缺点：需要创建一个`Runnable`实现对象，并将其传递给`Thread`对象，稍微复杂一些。

### 线程池（Thread Pool）

除了上述两种方式外，Java还提供了线程池来管理线程的创建和执行。线程池通过复用一组线程来执行多个任务，避免了频繁创建和销毁线程的开销。

#### 使用Executor框架创建线程池：

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

public class ThreadPoolExample {
    public static void main(String[] args) {
        // 创建固定大小的线程池
        ExecutorService executorService = Executors.newFixedThreadPool(3);

        // 提交任务给线程池
        for (int i = 0; i < 5; i++) {
            executorService.submit(new MyRunnable());
        }

        // 关闭线程池
        executorService.shutdown();
    }
}

class MyRunnable implements Runnable {
    @Override
    public void run() {
        // 线程任务
        for (int i = 0; i < 5; i++) {
            System.out.println(Thread.currentThread().getName() + " - " + i);
            try {
                Thread.sleep(1000); // 休眠1秒
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}
```

通过以上几种方法，可以在Java中创建和管理线程，满足不同的并发编程需求。线程池尤其适用于高并发环境下的任务执行和管理。