Java多线程实现之Thread类深度解析

- 一、多线程基础概念
- - 1.1 什么是线程
  - 1.2 多线程的优势
  - 1.3 Java多线程模型
- 二、Thread类的基本结构与构造函数
- - 2.1 Thread类的继承关系
  - 2.2 构造函数
- 三、创建和启动线程
- - 3.1 继承Thread类创建线程
  - 3.2 实现Runnable接口创建线程
- 四、Thread类的核心方法
- - 4.1 start()方法
  - 4.2 run()方法
  - 4.3 join()方法
  - 4.4 sleep(long millis)方法
  - 4.5 yield()方法
  - 4.6 setPriority(int priority)和getPriority()方法
- 五、线程的生命周期
- - 5.1 新建状态（New）
  - 5.2 就绪状态（Runnable）
  - 5.3 运行状态（Running）
  - 5.4 阻塞状态（Blocked）
  - 5.5 死亡状态（Terminated）
- 六、线程同步与互斥
- - 6.1 线程安全问题
  - 6.2 synchronized关键字
  - 6.3 Lock接口
- 七、Thread类的高级特性
- - 7.1 守护线程（Daemon Thread）
  - 7.2 线程组（Thread Group）
- 八、实战案例
- - 8.1 多线程文件读取
  - 8.2 多线程爬虫
- 九、注意事项与常见问题
- - 9.1 避免死锁
  - 9.2 正确处理InterruptedException
  - 9.3 线程资源管理

多线程技术是提升程序性能和响应能力的重要手段，Java提供了强大且灵活的多线程支持，其中Thread类作为Java多线程编程的基础，提供了创建、管理和控制线程的核心功能。本文我将深入探讨Thread类的原理、使用方法、高级特性以及实战应用，带你全面掌握Java多线程编程的核心技术。

一、多线程基础概念

1.1 什么是线程

线程（Thread）是进程中的一个执行单元，是程序执行的最小单位。一个进程可以包含多个线程，这些线程共享进程的资源（如内存、文件句柄等），并可以并发执行。与进程相比，线程的创建和销毁开销更小，因此在提高程序效率和资源利用率方面具有显著优势。

1.2 多线程的优势

提高程序响应性：在图形界面程序中，多线程可以让界面线程与工作线程分离，避免界面卡顿。
提升执行效率：利用多核CPU资源，多个线程可以并行执行，加快任务处理速度。
资源共享：同一进程内的线程共享资源，减少了资源分配和回收的开销。

1.3 Java多线程模型

Java通过java.lang.Thread类和java.lang.Runnable接口支持多线程编程。Thread类是线程的核心类，而Runnable接口则提供了一种更灵活的方式来定义线程任务。

二、Thread类的基本结构与构造函数

2.1 Thread类的继承关系

java.lang.Object
↳ java.lang.Thread

Thread类继承自Object类，并实现了Runnable接口，这使得Thread类既可以作为线程对象使用，也可以作为线程任务的载体。

2.2 构造函数

Thread类提供了多个构造函数，常用的有以下几种：

Thread()：创建一个新的线程对象，但未指定线程任务。

Thread thread = new Thread();

Thread(Runnable target)：创建一个新的线程对象，并将Runnable实现类作为线程任务。

Runnable task = () -> System.out.println("线程任务执行中");
Thread thread = new Thread(task);

Thread(String name)：创建一个指定名称的线程对象。

Thread namedThread = new Thread("MyThread");

Thread(Runnable target, String name)：创建一个指定名称且包含线程任务的线程对象。

Runnable task = () -> System.out.println("命名线程任务执行中");
Thread namedTaskThread = new Thread(task, "TaskThread");

三、创建和启动线程

3.1 继承Thread类创建线程

通过继承Thread类并重写其run()方法来定义线程任务：

class MyThread extends Thread {
    @Override
    public void run() {
        for (int i = 0; i < 5; i++) {
            System.out.println("MyThread执行: " + i);
        }
    }
}

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

注意：启动线程需调用start()方法，而不是直接调用run()方法。直接调用run()方法相当于普通的方法调用，不会开启新线程。

3.2 实现Runnable接口创建线程

实现Runnable接口并将其作为参数传递给Thread类的构造函数：

class MyRunnable implements Runnable {
    @Override
    public void run() {
        for (int i = 0; i < 5; i++) {
            System.out.println("MyRunnable执行: " + i);
        }
    }
}

public class RunnableExample {
    public static void main(String[] args) {
        MyRunnable runnable = new MyRunnable();
        Thread thread = new Thread(runnable);
        thread.start();
    }
}

对比分析：

继承Thread类：代码简单直观，但由于Java单继承限制，扩展性较差。
实现Runnable接口：更灵活，可实现多个接口，便于资源共享，推荐使用。

四、Thread类的核心方法

4.1 start()方法

start()方法用于启动线程，使线程进入就绪状态。JVM会为该线程分配资源，并在合适的时机执行其run()方法。一个线程只能调用一次start()方法，重复调用会抛出IllegalThreadStateException。

4.2 run()方法

run()方法定义了线程的具体任务逻辑。如果继承Thread类，需要重写该方法；如果通过Runnable接口创建线程，run()方法的实现逻辑在Runnable的实现类中。

4.3 join()方法

join()方法用于让当前线程等待指定线程执行完毕。例如：

public class JoinExample {
    public static void main(String[] args) {
        Thread thread = new Thread(() -> {
            try {
                Thread.sleep(2000);  // 模拟线程执行耗时任务
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("子线程执行完毕");
        });
        
        thread.start();
        
        try {
            thread.join();  // 主线程等待子线程执行完毕
            System.out.println("子线程已结束，主线程继续执行");
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

4.4 sleep(long millis)方法

sleep()方法使当前线程暂停执行指定的毫秒数，线程进入阻塞状态。该方法会抛出InterruptedException异常，需要进行异常处理。

public class SleepExample {
    public static void main(String[] args) {
        Thread thread = new Thread(() -> {
            for (int i = 0; i < 5; i++) {
                try {
                    Thread.sleep(1000);  // 每隔1秒执行一次
                    System.out.println("线程执行: " + i);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });
        
        thread.start();
    }
}

4.5 yield()方法

yield()方法使当前线程主动让出CPU资源，进入就绪状态，允许其他具有相同优先级的线程执行。但该方法并不能保证一定会切换到其他线程。

4.6 setPriority(int priority)和getPriority()方法

setPriority()方法用于设置线程的优先级，范围为Thread.MIN_PRIORITY（1）到Thread.MAX_PRIORITY（10），默认优先级为Thread.NORM_PRIORITY（5）。getPriority()方法用于获取线程的当前优先级。

Thread thread = new Thread(() -> {
    // 线程任务
});
thread.setPriority(Thread.MAX_PRIORITY);  // 设置最高优先级
int priority = thread.getPriority();  // 获取优先级

五、线程的生命周期

5.1 新建状态（New）

当使用new关键字创建一个Thread对象时，线程处于新建状态，此时线程尚未启动。

5.2 就绪状态（Runnable）

调用start()方法后，线程进入就绪状态，等待JVM调度执行。处于就绪状态的线程可能在CPU上运行，也可能在等待CPU资源。

5.3 运行状态（Running）

当线程被JVM选中并分配CPU资源时，线程进入运行状态，执行run()方法中的代码。

5.4 阻塞状态（Blocked）

线程因某些原因（如调用sleep()、join()方法，等待锁等）暂停执行，进入阻塞状态。阻塞状态的线程不会占用CPU资源。

5.5 死亡状态（Terminated）

当线程的run()方法执行完毕，或者因异常终止时，线程进入死亡状态，此时线程无法再被启动。

六、线程同步与互斥

6.1 线程安全问题

多线程环境下，如果多个线程同时访问共享资源，可能会导致数据不一致等线程安全问题。例如，多个线程同时对一个计数器进行自增操作，可能会出现结果错误。

6.2 synchronized关键字

synchronized关键字用于实现线程同步，保证同一时刻只有一个线程可以访问被synchronized修饰的代码块或方法。

class Counter {
    private int count = 0;
    
    public synchronized void increment() {
        count++;
    }
    
    public int getCount() {
        return count;
    }
}

public class SynchronizedExample {
    public static void main(String[] args) {
        Counter counter = new Counter();
        
        Thread thread1 = new Thread(() -> {
            for (int i = 0; i < 1000; i++) {
                counter.increment();
            }
        });
        
        Thread thread2 = new Thread(() -> {
            for (int i = 0; i < 1000; i++) {
                counter.increment();
            }
        });
        
        thread1.start();
        thread2.start();
        
        try {
            thread1.join();
            thread2.join();
            System.out.println("最终计数: " + counter.getCount());
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

6.3 Lock接口

java.util.concurrent.locks.Lock接口提供了比synchronized更灵活的锁机制，如可重入锁（ReentrantLock）、读写锁（ReadWriteLock）等。

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

class LockExample {
    private int count = 0;
    private Lock lock = new ReentrantLock();
    
    public void increment() {
        lock.lock();
        try {
            count++;
        } finally {
            lock.unlock();
        }
    }
    
    public int getCount() {
        return count;
    }
}

七、Thread类的高级特性

7.1 守护线程（Daemon Thread）

守护线程是一种特殊的线程，用于为其他线程提供服务。当所有非守护线程结束时，JVM会自动终止所有守护线程。通过setDaemon(true)方法可以将线程设置为守护线程，且必须在start()方法之前调用。

public class DaemonThreadExample {
    public static void main(String[] args) {
        Thread daemonThread = new Thread(() -> {
            while (true) {
                System.out.println("守护线程运行中...");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });
        
        daemonThread.setDaemon(true);  // 设置为守护线程
        daemonThread.start();
        
        try {
            Thread.sleep(3000);  // 主线程执行3秒后结束
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        
        System.out.println("主线程结束");
    }
}

7.2 线程组（Thread Group）

线程组用于管理一组线程，可以统一设置线程的优先级、守护状态等属性，还可以批量中断线程组内的所有线程。

public class ThreadGroupExample {
    public static void main(String[] args) {
        ThreadGroup group = new ThreadGroup("MyGroup");
        
        Thread thread1 = new Thread(group, () -> {
            try {
                Thread.sleep(2000);
                System.out.println("线程1执行完毕");
            } catch (InterruptedException e) {
                System.out.println("线程1被中断");
            }
        });
        
        Thread thread2 = new Thread(group, () -> {
            try {
                Thread.sleep(3000);
                System.out.println("线程2执行完毕");
            } catch (InterruptedException e) {
                System.out.println("线程2被中断");
            }
        });
        
        thread1.start();
        thread2.start();
        
        group.interrupt();  // 中断线程组内的所有线程
    }
}

八、实战案例

8.1 多线程文件读取

使用多线程同时读取多个文件，提高读取效率：

import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;

class FileReaderThread extends Thread {
    private String filePath;
    
    public FileReaderThread(String filePath) {
        this.filePath = filePath;
    }
    
    @Override
    public void run() {
        try (BufferedReader reader = new BufferedReader(new FileReader(filePath))) {
            String line;
            while ((line = reader.readLine()) != null) {
                System.out.println(filePath + ": " + line);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

public class MultiThreadFileRead {
    public static void main(String[] args) {
        String[] filePaths = {"file1.txt", "file2.txt", "file3.txt"};
        
        for (String filePath : filePaths) {
            FileReaderThread thread = new FileReaderThread(filePath);
            thread.start();
        }
    }
}

8.2 多线程爬虫

利用多线程同时抓取多个网页数据：

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.net.URL;

class CrawlerThread extends Thread {
    private String url;
    
    public CrawlerThread(String url) {
        this.url = url;
    }
    
    @Override
    public void run() {
        try (BufferedReader reader = new BufferedReader(
                new InputStreamReader(new URL(url).openStream()))) {
            String line;
            while ((line = reader.readLine()) != null) {
                System.out.println(url + ": " + line);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

public class MultiThreadCrawler {
    public static void main(String[] args) {
        String[] urls = {"https://example.com", "https://google.com", "https://baidu.com"};
        
        for (String url : urls) {
            CrawlerThread thread = new CrawlerThread(url);
            thread.start();
        }
    }
}