线程（Thread）是操作系统中能够独立执行任务的最小单位。它是进程（Process）的一部分，每个进程至少包含一个线程，称为主线程。线程通过操作系统的线程调度机制执行程序代码，并共享进程中的资源（如内存、文件描述符等）。多个线程在同一进程中并发执行，可以提高程序的执行效率和响应能力。

线程的基本概念

1. 进程与线程的关系

   • 进程是操作系统分配资源的基本单位。每个进程都有自己的独立地址空间、文件描述符、堆栈等资源。
   • 线程是操作系统调度的基本单位，一个进程可以包含多个线程。线程之间共享进程的内存空间，但每个线程有自己的栈和程序计数器（PC）。

2. 线程的特点

   • 共享资源：同一进程中的线程共享进程的内存空间、文件描述符、信号量等资源。
   • 独立执行：每个线程有自己的执行路径（即程序计数器、寄存器等），可以独立执行任务。
   • 轻量级：相比进程，线程的创建和销毁开销较小，因为线程共享进程的资源。
   • 并发执行：多个线程可以并发执行，执行的顺序由操作系统的调度器控制。

3. 线程的状态 线程的生命周期通常有以下几种状态：

   • 新建（New）：线程被创建，但尚未开始执行。
   • 就绪（Runnable）：线程已经准备好，可以开始执行，但操作系统的线程调度器决定是否分配 CPU 时间给该线程。
   • 运行（Running）：线程正在执行代码。
   • 阻塞（Blocked）：线程由于某些条件未满足而被挂起，例如等待 I/O 操作完成、等待锁等。
   • 终止（Terminated）：线程执行完成，或者由于异常或其他原因结束。

4. 线程的创建与管理

   • 在 Java 中，线程可以通过继承 Thread 类或实现 Runnable 接口来创建。
   • Thread 类表示一个线程，提供了线程的生命周期管理方法，如 start()、run()、sleep()、join() 等。
   • Runnable 接口则表示一个任务，可以通过 Thread 对象的构造函数将其包装成线程。

示例：使用 Thread 类创建线程

复制
1class MyThread extends Thread {
2    @Override
3    public void run() {
4        System.out.println("Thread is running");
5    }
6}
7
8public class ThreadExample {
9    public static void main(String[] args) {
10        MyThread thread = new MyThread();
11        thread.start();  // 启动线程
12    }
13}

示例：使用 Runnable 接口创建线程

复制
1class MyRunnable implements Runnable {
2    @Override
3    public void run() {
4        System.out.println("Thread is running");
5    }
6}
7
8public class ThreadExample {
9    public static void main(String[] args) {
10        MyRunnable task = new MyRunnable();
11        Thread thread = new Thread(task);
12        thread.start();  // 启动线程
13    }
14}

5. 线程的同步 由于多个线程共享进程资源，在访问共享资源时可能会出现 竞态条件（Race Condition），导致数据不一致。为了避免这种情况，Java 提供了多种线程同步机制，最常见的包括：
   • synchronized：用于方法或代码块，保证同一时刻只有一个线程能够访问该代码块。
   • 锁（Lock）：Java 5 引入的 java.util.concurrent.locks 包提供了比 synchronized 更灵活的锁机制。
   • 原子操作：通过 java.util.concurrent.atomic 包提供的原子类（如 AtomicInteger）实现对基本类型的原子操作。

示例：使用 synchronized 保证线程同步

复制
1class Counter {
2    private int count = 0;
3
4    // 使用synchronized保证线程安全
5    public synchronized void increment() {
6        count++;
7    }
8
9    public synchronized int getCount() {
10        return count;
11    }
12}
13
14public class ThreadSyncExample {
15    public static void main(String[] args) throws InterruptedException {
16        Counter counter = new Counter();
17        
18        // 创建多个线程
19        Thread t1 = new Thread(() -> {
20            for (int i = 0; i < 1000; i++) {
21                counter.increment();
22            }
23        });
24        
25        Thread t2 = new Thread(() -> {
26            for (int i = 0; i < 1000; i++) {
27                counter.increment();
28            }
29        });
30        
31        t1.start();
32        t2.start();
33
34        // 等待线程执行完毕
35        t1.join();
36        t2.join();
37        
38        System.out.println("Count: " + counter.getCount());
39    }
40}

线程的调度

线程调度是操作系统管理多个线程并决定哪个线程在何时执行的过程。线程调度的主要任务是合理分配 CPU 时间给不同的线程，以提高系统的响应能力和资源利用率。常见的调度策略有：

1. 抢占式调度：操作系统定期检查线程的状态，并根据优先级、时间片等因素决定哪个线程可以执行。大多数现代操作系统采用这种方式。
2. 合作式调度：线程主动释放 CPU 控制权，让其他线程可以运行。这种方式不常见，只有在某些特定场景下才使用。

线程池

为了避免频繁创建和销毁线程带来的性能开销，Java 提供了 线程池（Thread Pool） 机制。线程池是一个包含多个线程的容器，线程池中的线程可以重复使用，执行完任务后不会销毁，而是返回线程池等待执行下一个任务。

Java 提供了 ExecutorService 接口及其实现类，如 ThreadPoolExecutor 和 ScheduledThreadPoolExecutor，用来管理线程池。

示例：使用 ExecutorService 创建线程池

复制
1import java.util.concurrent.ExecutorService;
2import java.util.concurrent.Executors;
3
4public class ThreadPoolExample {
5    public static void main(String[] args) {
6        // 创建一个固定大小的线程池
7        ExecutorService executorService = Executors.newFixedThreadPool(3);
8
9        // 提交任务给线程池
10        for (int i = 0; i < 5; i++) {
11            executorService.submit(() -> {
12                System.out.println(Thread.currentThread().getName() + " is executing the task.");
13            });
14        }
15
16        // 关闭线程池
17        executorService.shutdown();
18    }
19}