多线程基础：Java语言程序设计中的并发入门

概述

在现代计算机系统中，多线程技术已成为提升程序执行效率和响应能力的重要手段。Java语言作为广泛应用的编程语言，自身提供了强大的多线程支持，成为开发高性能和高并发应用的首选。第六章的第一节“多线程基础”旨在帮助考生系统理解Java多线程的基本概念、实现方式及其运行机制，为后续深入学习并发控制、线程同步等高级话题打下坚实基础。

本节学习目标包括：

• 理解线程的基本概念及多线程的必要性
• 掌握Java中创建和启动线程的两种主要方式
• 理解线程的生命周期及其状态转换
• 掌握线程的基本操作方法和常用API
• 通过实例理解多线程程序的设计与调试

通过本节内容的学习，考生能够熟练编写和调试多线程程序，理解并发执行带来的优势和挑战，为计算机等级考试二级Java语言程序设计部分的多线程内容奠定坚实基础。

核心概念

线程（Thread）

线程是程序执行的最小单位，一个进程中可以包含多个线程。每个线程都有自己独立的执行路径，但共享进程的资源。

进程（Process）

进程是程序运行时的一个独立实体，拥有自己的内存空间和系统资源。

多线程（Multithreading）

指在同一进程中同时运行多个线程，实现并发执行，从而提升程序的效率和资源利用率。

并发（Concurrency）

指多个线程在同一时间段内交替执行，合理调度CPU资源，实现任务的“同时”进行。

线程状态（Thread State）

线程在运行过程中的不同状态，包括新建（New）、就绪（Runnable）、运行（Running）、阻塞（Blocked）、等待（Waiting）、计时等待（Timed Waiting）、终止（Terminated）。

线程优先级（Priority）

线程的调度优先级，影响线程获得CPU时间片的先后顺序。

原理分析

线程的工作原理

Java线程是基于操作系统的线程机制实现的，Java虚拟机（JVM）通过映射Java线程到操作系统原生线程来实现。线程通过CPU调度获得执行时间，多个线程交替执行形成并发效果。

线程切换与调度

线程调度由操作系统负责，基于优先级和时间片轮转算法。线程切换涉及上下文切换，保存和恢复线程状态，频繁切换可能导致性能下降。

线程同步原理

多线程共享资源时，若无同步措施，可能产生数据竞争和不一致。Java通过同步机制（synchronized关键字、Lock接口等）保证线程访问共享资源的互斥性，避免数据冲突。

线程生命周期管理

线程从创建到销毁经历多个状态，合理管理线程生命周期，有助于避免死锁、资源浪费和程序异常。

详细内容

1. 线程的创建方式

Java中创建线程主要有两种方式：

1.1 继承Thread类

• 定义一个类继承java.lang.Thread，重写run()方法。
• 创建该类对象，调用start()方法启动线程。

示例代码：

class MyThread extends Thread {
    public void run() {
        System.out.println("Thread running: " + Thread.currentThread().getName());
    }
}

public class TestThread {
    public static void main(String[] args) {
        MyThread t1 = new MyThread();
        t1.start();
    }
}

注意：调用start()方法启动线程，不能直接调用run()，否则只是普通方法调用，不能实现多线程。

1.2 实现Runnable接口

• 定义一个类实现java.lang.Runnable接口，重写run()方法。
• 创建Thread对象，构造时传入Runnable实现类对象。
• 调用Thread对象的start()方法启动线程。

示例代码：

class MyRunnable implements Runnable {
    public void run() {
        System.out.println("Runnable thread: " + Thread.currentThread().getName());
    }
}

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

这种方式适合避免Java单继承限制，灵活性更高。

2. 线程的生命周期

线程状态转换图说明了线程从创建到终止的全过程。

状态	描述
新建（New）	线程对象已创建，尚未启动
就绪（Runnable）	线程准备运行，等待CPU调度
运行（Running）	线程获得CPU时间片，执行run()方法
阻塞（Blocked）	线程等待获取锁或资源，无法执行
等待（Waiting）	线程无限期等待其他线程通知
计时等待（Timed Waiting）	线程等待指定时间后恢复
终止（Terminated）	线程完成执行或异常结束

了解线程状态，有助于调试程序和设计合理的并发逻辑。

3. 线程的基本操作

Java Thread类提供多种常用方法：

• start()：启动线程，调用run()方法
• run()：线程执行体，建议重写
• sleep(long millis)：使线程休眠指定毫秒数
• yield()：让出CPU，线程进入就绪状态
• join()：等待线程终止
• setPriority(int)：设置线程优先级
• getName()：获取线程名
• setName(String)：设置线程名
• isAlive()：判断线程是否存活

4. 线程间的通信基础

多线程程序中，线程之间需要协同工作。Java提供了wait()、notify()、notifyAll()方法，配合synchronized实现线程间通信。

• wait()：使当前线程等待并释放锁
• notify()：唤醒一个等待线程
• notifyAll()：唤醒所有等待线程

正确使用这些方法可以实现线程间的协作与数据同步。

实例分析

实例1：继承Thread创建和运行线程

背景：实现两个线程分别打印数字和字母。

代码示例：

class NumberThread extends Thread {
    public void run() {
        for (int i = 1; i <= 5; i++) {
            System.out.println("Number: " + i);
            try { Thread.sleep(200); } catch (InterruptedException e) {}
        }
    }
}

class LetterThread extends Thread {
    public void run() {
        for (char c = 'A'; c <= 'E'; c++) {
            System.out.println("Letter: " + c);
            try { Thread.sleep(200); } catch (InterruptedException e) {}
        }
    }
}

public class ThreadTest {
    public static void main(String[] args) {
        NumberThread t1 = new NumberThread();
        LetterThread t2 = new LetterThread();
        t1.start();
        t2.start();
    }
}

分析：两个线程交替执行，打印数字和字母，展示多线程并发执行的效果。

结论：通过继承Thread类，轻松实现多线程。

实例2：实现Runnable接口创建线程并共享资源

背景：多个线程对同一个计数器进行递增操作。

代码示例：

class Counter implements Runnable {
    private int count = 0;

    public void run() {
        for (int i = 0; i < 5; i++) {
            increment();
            try { Thread.sleep(100); } catch (InterruptedException e) {}
        }
    }

    public synchronized void increment() {
        count++;
        System.out.println(Thread.currentThread().getName() + " count: " + count);
    }
}

public class CounterTest {
    public static void main(String[] args) {
        Counter counter = new Counter();
        Thread t1 = new Thread(counter, "Thread-1");
        Thread t2 = new Thread(counter, "Thread-2");
        t1.start();
        t2.start();
    }
}

分析：两个线程共享同一Counter对象，通过synchronized关键字确保递增操作的原子性，避免数据竞争。

结论：实现Runnable接口适合共享资源的多线程设计。

实例3：线程状态演示

背景：通过控制sleep和join方法，观察线程状态变化。

代码示例：

public class ThreadStateDemo {
    public static void main(String[] args) {
        Thread t = new Thread(() -> {
            try {
                Thread.sleep(500);
                System.out.println("Thread running");
            } catch (InterruptedException e) {}
        });

        System.out.println("State after creation: " + t.getState()); // NEW
        t.start();
        System.out.println("State after start: " + t.getState()); // RUNNABLE

        try {
            t.join();
        } catch (InterruptedException e) {}

        System.out.println("State after completion: " + t.getState()); // TERMINATED
    }
}

分析：通过getState()方法获取线程不同时间点的状态，验证线程生命周期。

结论：掌握线程状态有助于调试和优化多线程程序。

常见误区

1. 误区：直接调用run()方法启动线程

   • 错误原因：run()只是普通方法调用，线程不会并发执行。
   • 正确做法：调用start()方法启动线程。

2. 误区：忽略线程同步导致数据竞争

   • 错误原因：多线程访问共享变量未加锁，数据可能混乱。
   • 正确做法：使用synchronized或Lock机制保护共享资源。

3. 误区：线程死锁不处理

   • 错误原因：多个线程相互等待对方释放资源，程序停止响应。
   • 正确做法：避免嵌套锁，合理设计锁顺序，使用死锁检测工具。

4. 误区：滥用线程优先级

   • 错误原因：过度依赖优先级导致线程饥饿，调度不可预测。
   • 正确做法：优先级作为参考，设计线程任务合理分配。

5. 误区：忽视线程终止状态

   • 错误原因：线程结束后继续操作该线程对象，导致异常。
   • 正确做法：判断线程状态或重新创建线程对象。

应用场景

• 并行计算：利用多线程同时处理大量计算任务，如科学计算、图像处理等。
• 网络编程：服务器端处理多个客户端请求，提升响应速度。
• 用户界面：主线程处理界面渲染，子线程处理耗时操作，避免界面卡顿。
• 数据处理：多线程读取、写入文件或数据库，提高I/O效率。
• 实时监控：多个线程同时监控不同系统指标，保证系统稳定。

知识拓展

• 线程池技术：通过线程池复用线程资源，避免频繁创建销毁线程带来的开销。
• volatile关键字：保证变量的可见性，防止线程缓存导致的数据不一致。
• Lock接口及Condition：比synchronized更灵活的锁机制，支持多条件等待。
• 线程安全集合：如ConcurrentHashMap，支持高效并发访问。
• Java内存模型：理解线程之间共享变量的内存可见性和有序性规则。

总结回顾

本节内容全面介绍了Java多线程的基础知识，包括线程的概念、创建方式、生命周期、基本操作及线程间通信的基础。通过理论讲解与代码实例，考生能够清晰理解多线程的工作机制和实现方法。掌握常见误区，避免多线程开发中的常见陷阱。结合实际应用场景，认识多线程技术在现代软件开发中的重要地位。为后续学习并发控制、线程同步等内容奠定坚实基础。

keyPoints

1. 线程是程序执行的最小单位，Java通过Thread类和Runnable接口实现多线程
2. Java中创建线程有两种主要方式：继承Thread和实现Runnable接口
3. 线程生命周期包括新建、就绪、运行、阻塞、等待、计时等待和终止等状态
4. 启动线程必须调用start()方法，直接调用run()不会启动新线程
5. 线程切换由操作系统调度，频繁切换可能影响性能
6. 线程同步防止数据竞争，常用synchronized关键字
7. wait()、notify()、notifyAll()实现线程间通信
8. 常见误区包括误用run()方法、忽视同步、死锁问题等
9. 多线程广泛应用于并行计算、网络编程、界面响应等场景
10. 理解线程基础为深入学习Java并发编程奠定基础