Java大师成长计划之第15天：Java线程基础

📢 友情提示：

本文由银河易创AI（https://ai.eaigx.com）平台gpt-4o-mini模型辅助创作完成，旨在提供灵感参考与技术分享，文中关键数据、代码与结论建议通过官方渠道验证。

在现代软件开发中，多线程编程是实现高性能应用的重要手段。Java作为一种具有强大并发能力的语言，提供了丰富的线程操作API。在本篇文章中，我们将深入探讨Java线程的创建、生命周期及相关概念，帮助你在并发编程的道路上更进一步。

一. 什么是线程？

线程是操作系统调度的基本单位，它是进程内的一个独立执行单元。一个进程可以包含多个线程，这些线程共享同一进程的资源（如内存、文件句柄等），但每个线程有自己的寄存器、堆栈等私有资源。由于线程之间共享内存，它们的通信和数据共享比进程之间更为高效，但也因此更容易出现并发问题。

1.1 线程与进程的关系

进程是系统进行资源分配和调度的基本单位，而线程是程序执行的最小单位。一个进程至少包含一个线程，即主线程。进程间的通信通常使用IPC（Inter Process Communication）技术，如管道、消息队列等，而线程间的通信相对简单，通常通过共享内存、锁机制等方式实现。

线程的优势：

• 提高程序的响应能力：通过将不同的任务分配到多个线程上，可以提高程序的并发能力，例如在一个Web服务器中，可以为每个客户端请求分配一个线程，从而提高系统的并发性能。
• 资源共享：线程共享进程的内存和文件句柄等资源，这使得线程之间的通信更加高效，而进程间则需要通过IPC机制来交换数据。
• 减少上下文切换开销：相比进程，线程的创建和销毁开销较小，且线程之间的上下文切换速度比进程切换更快。

线程的缺点：

• 线程间的同步问题：多个线程共享同一块内存区域，可能会导致数据不一致的问题。为了保证线程安全，通常需要采用同步机制（如sychronized关键字、Lock接口等）来避免数据冲突。
• 死锁问题：当多个线程互相等待对方持有的锁时，可能会导致死锁，从而使程序无法继续执行。为此，避免死锁和设计合理的锁策略成为并发编程的一个重要问题。

1.2 线程的分类

线程通常分为以下几类：

• 用户级线程：由应用程序创建和控制，操作系统并不直接管理这些线程。
• 内核级线程：由操作系统内核管理，操作系统直接调度执行。Java的线程通常是内核级线程，操作系统会为其分配CPU时间。
• 守护线程：守护线程是为其他线程提供服务的线程，它通常用于后台任务。Java中，像垃圾回收器（GC）就是通过守护线程来运行的。当所有非守护线程结束时，守护线程会自动退出。

1.3 线程的重要性

随着多核处理器的普及，传统的单线程处理方式已经无法满足高并发应用的需求。在这种背景下，Java的多线程机制显得尤为重要。通过合理的线程管理，我们能够有效提高应用程序的吞吐量和响应时间，为用户提供更流畅的使用体验。

---

二. Java中的线程创建

在Java中，线程的创建和管理是多线程编程的核心。Java为我们提供了多种方式来创建线程，以下是三种常见的方法：

2.1 继承Thread类

通过继承Thread类并重写run()方法来定义线程的执行逻辑。继承Thread类创建线程的方式相对简单，但有一个限制：由于Java单继承的特性，类只能继承一个类，因此，如果需要继承其他类时无法再继承Thread类。

class MyThread extends Thread {@Overridepublic void run() {System.out.println("Thread is running.");}
}public class ThreadDemo {public static void main(String[] args) {MyThread thread = new MyThread(); // 创建线程实例thread.start(); // 启动线程}
}

在这个例子中，我们定义了一个继承Thread类的MyThread类，并重写了run()方法。start()方法是启动线程的关键，它会调用run()方法，执行线程的任务。

注意：调用run()方法并不会启动线程。若直接调用run()方法，只会在当前线程中执行run()方法中的代码，而不会在新线程中执行。只有调用start()方法，才会创建一个新的线程。

2.2 实现Runnable接口

另一种创建线程的方式是通过实现Runnable接口。这种方式相较于继承Thread类有一个重要的优点：它支持多个线程共享同一个资源，适合多个线程执行相同的任务。

class MyRunnable implements Runnable {@Overridepublic void run() {System.out.println("Runnable thread is running.");}
}public class RunnableDemo {public static void main(String[] args) {MyRunnable myRunnable = new MyRunnable();Thread thread = new Thread(myRunnable); // 创建线程thread.start(); // 启动线程}
}

这种方式不仅能够实现多线程，还能够让多个线程共享同一个Runnable对象。通过实现Runnable接口，我们可以使得线程的任务更加灵活，因为一个线程类可以继承其他类，同时实现多个接口。

2.3 使用Executor框架

从Java 5开始，java.util.concurrent包引入了Executor框架，它提供了一种更为简洁、灵活的方式来管理线程池。线程池可以有效地避免频繁创建和销毁线程的开销，尤其在高并发场景下，线程池显得尤为重要。

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;public class ExecutorDemo {public static void main(String[] args) {ExecutorService executor = Executors.newFixedThreadPool(2); // 创建一个固定大小的线程池// 提交任务到线程池executor.submit(() -> {System.out.println("Task 1 is running.");});executor.submit(() -> {System.out.println("Task 2 is running.");});executor.shutdown(); // 关闭线程池}
}

在这个例子中，我们使用Executors.newFixedThreadPool(2)创建了一个包含两个线程的线程池。通过submit()方法提交任务，线程池会管理线程的生命周期并执行任务。使用线程池能够有效减少线程创建和销毁的开销，同时避免资源浪费。

ExecutorService接口提供了许多方法，例如submit()、invokeAll()等，可以帮助我们更高效地管理线程池中的线程。

2.4 使用Callable和Future

在某些情况下，我们希望能够获取线程执行的结果，这时可以使用Callable接口和Future类。与Runnable不同，Callable可以返回一个结果并且允许抛出异常。Future则可以用来获取线程的执行结果或者取消线程的执行。

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;public class CallableDemo {public static void main(String[] args) throws ExecutionException, InterruptedException {ExecutorService executor = Executors.newCachedThreadPool();Callable<Integer> task = () -> {return 42; // 任务返回结果};Future<Integer> future = executor.submit(task); // 提交任务Integer result = future.get(); // 获取任务结果System.out.println("Task result: " + result);executor.shutdown(); // 关闭线程池}
}

在这个例子中，Callable任务返回一个整数，我们使用Future.get()方法获取线程的执行结果。如果线程执行异常，get()方法会抛出ExecutionException。

---

通过以上几种方式，我们可以在Java中灵活地创建和管理线程。每种方法都有其特定的应用场景，开发者需要根据实际需求选择合适的线程创建方式。随着多线程编程的深入，你将发现线程池等高级特性能够显著提高应用程序的性能和可扩展性。

三. Java线程的生命周期

线程生命周期指的是线程从创建到结束的整个过程。Java中的线程具有不同的状态，线程的状态决定了它在运行时所处的阶段。了解线程的生命周期和各个状态之间的转换，对于编写高效的并发程序至关重要。下面我们将详细介绍Java线程的生命周期，并且解析每个线程状态的含义。

3.1 线程生命周期的各个状态

Java中的线程有五种主要的状态，每个线程在生命周期中可能会处于这五种状态中的任何一种。线程状态之间的转变是由Java虚拟机（JVM）和操作系统的调度机制控制的。

1. 新建状态（New）
2. 就绪状态（Runnable）
3. 运行状态（Running）
4. 阻塞状态（Blocked）
5. 等待状态（Waiting）
6. 超时等待状态（Timed Waiting）
7. 死亡状态（Terminated）

在这些状态之间，线程的状态会随着线程生命周期的推进发生相互转换。我们可以通过Thread类的方法来观察线程的状态，例如getState()方法。

3.2 线程状态的详细介绍

3.2.1 新建状态（New）

当我们创建一个线程对象，但尚未调用start()方法时，线程处于新建状态。此时，线程并没有开始执行，所有的初始化工作已经完成，但还没有分配CPU资源。

• 线程转换条件：线程从新建状态进入就绪状态的条件是调用了start()方法。

Thread thread = new Thread(() -> {System.out.println("Thread is running.");
});
System.out.println(thread.getState());  // 输出：NEW
thread.start(); // 线程从NEW状态变为RUNNABLE

3.2.2 就绪状态（Runnable）

当线程调用了start()方法后，线程进入就绪状态。此时线程已经准备好，等待操作系统调度器为其分配CPU时间片。需要注意的是，在Java中，“就绪状态”和“运行状态”有时被称为“可运行状态”，它们的区别仅在于线程是否获得CPU时间片。

• 线程转换条件：线程处于就绪状态时，操作系统调度器会选择合适的线程进行运行。因此，它会在就绪状态和运行状态之间不断切换。

Thread thread = new Thread(() -> {System.out.println("Thread is running.");
});
thread.start(); // 线程从NEW状态变为RUNNABLE状态

线程从就绪状态进入运行状态的前提是操作系统的线程调度程序为它分配了CPU时间片。

3.2.3 运行状态（Running）

当线程获得操作系统的CPU时间片后，它将进入运行状态。此时，线程开始执行run()方法中的代码。线程运行时，CPU会执行线程的指令。多个线程同时运行时，操作系统会进行线程调度，根据调度算法来分配CPU资源。

• 线程转换条件：线程从就绪状态进入运行状态，或者在线程正在运行时，操作系统的调度器重新分配CPU时间片。

Thread thread = new Thread(() -> {System.out.println("Thread is running.");
});
thread.start(); // 线程进入RUNNABLE状态，操作系统开始调度并执行该线程

当线程完成run()方法中的代码或者被操作系统中断时，它会离开运行状态，进入阻塞或等待状态，或者直接进入死亡状态。

3.2.4 阻塞状态（Blocked）

阻塞状态通常发生在一个线程试图访问被其他线程持有的同步锁（如sychronized块或Lock对象）时。此时，线程被挂起，直到它能够获取到需要的锁。阻塞状态下的线程不消耗CPU时间，它们处于等待锁的状态。

• 线程转换条件：当一个线程的执行遇到阻塞条件（如锁竞争），它就会进入阻塞状态。此时，线程不再参与操作系统的调度，直到它获取到所需的资源。

public class BlockedStateExample {private static final Object lock = new Object();public static void main(String[] args) {Thread thread1 = new Thread(() -> {synchronized (lock) {try {Thread.sleep(2000);} catch (InterruptedException e) {e.printStackTrace();}}});Thread thread2 = new Thread(() -> {synchronized (lock) {System.out.println("Thread 2 is running.");}});thread1.start();thread2.start();}
}

在上述代码中，thread2试图获取lock对象的锁，但thread1正在持有锁。因此，thread2进入了阻塞状态，直到thread1释放锁。

3.2.5 等待状态（Waiting）

当一个线程调用Object.wait()、Thread.join()、LockSupport.park()等方法时，它会进入等待状态。在等待状态下，线程不占用CPU时间，直到收到其他线程的通知或者中断信号。

• 线程转换条件：线程在等待状态时，必须有其他线程通过notify()、notifyAll()、interrupt()等方法唤醒或中断它，才能重新进入就绪状态。

public class WaitingStateExample {public static void main(String[] args) throws InterruptedException {Thread thread = new Thread(() -> {try {Thread.sleep(1000);synchronized (this) {wait(); // 线程进入WAITING状态}} catch (InterruptedException e) {e.printStackTrace();}});thread.start();Thread.sleep(500); // 确保线程已经进入等待状态thread.interrupt(); // 中断线程，线程会离开WAITING状态}
}

线程进入等待状态后，必须经过其他线程的操作才能继续执行。

3.2.6 超时等待状态（Timed Waiting）

当一个线程调用如Thread.sleep(millis)、Object.wait(millis)或Thread.join(millis)等带有时间参数的方法时，线程会进入超时等待状态。在这种状态下，线程会等待一段时间，超时后自动回到就绪状态。

• 线程转换条件：在超时等待状态下，线程等待指定时间后会自动回到就绪状态，或者在等待过程中被其他线程唤醒。

public class TimedWaitingStateExample {public static void main(String[] args) throws InterruptedException {Thread thread = new Thread(() -> {try {Thread.sleep(2000); // 线程进入TIMED_WAITING状态，等待2秒System.out.println("Thread has woken up.");} catch (InterruptedException e) {e.printStackTrace();}});thread.start();}
}

在线程执行Thread.sleep()时，线程会进入超时等待状态，超时后线程自动进入就绪状态。

3.2.7 死亡状态（Terminated）

当线程的run()方法执行完成，或者线程因异常终止时，线程进入死亡状态。在死亡状态下，线程无法重新启动。

• 线程转换条件：线程在run()方法执行完毕或由于异常而终止时进入死亡状态，无法再恢复为活动状态。

Thread thread = new Thread(() -> {System.out.println("Thread is running.");
});thread.start();

一旦线程的执行结束，或者遇到异常未处理，线程便进入死亡状态，无法再调用start()方法。

---

3.3 线程状态转换图

线程在生命周期中会经历多个状态，并根据不同的条件转换。以下是一个简化的线程状态图：

   +-----------+|   新建    | --------------------++-----------+                    ||                         || start()               ||                         |+-----------+                    ||  就绪    | <-----------------++-----------+                    ||                         || run()                  ||                         |+-----------+                    ||  运行    | ------------+      |+-----------+            |      ||                 +-----+ ||                 | 等待 | ||                 +-----+ ||                       |   ||                       |   ||             +---------+ ||             |  阻塞   | ||             +---------+ ||                       |   |+-----------------------+   ||+----------+---------+|        死亡       |+-------------------+

3.4 总结

理解线程的生命周期和各种线程状态是编写高效且稳定的多线程程序的基础。在并发编程中，线程的调度和资源管理是复杂且关键的。通过正确地控制线程的状态转换，可以有效避免常见的并发问题，如死锁、资源竞争等。

在实际开发中，掌握线程的生命周期，合理运用同步机制和线程池等工具，将有助于提升应用程序的性能和稳定性。

四. 线程的安全性

线程安全性是多线程编程中最为重要的概念之一。由于多个线程可能会同时访问共享的资源，这就导致了线程安全问题。线程安全的意思是，当多个线程并发访问同一资源时，不会发生数据竞争或不可预期的行为。为了确保线程安全，开发者需要采取适当的措施来保证共享资源的正确访问。

4.1 线程安全问题的根源

线程安全问题通常出现在多个线程同时访问共享资源（如内存、变量、对象等）时，特别是当多个线程需要对同一资源进行读写操作时，若没有适当的同步机制，容易出现以下几种问题：

• 竞态条件（Race Condition）：当两个或更多线程并发执行时，如果它们对同一资源进行读写操作，而且这些操作不是原子性的，就可能导致数据的不一致。例如，线程A和线程B同时读取一个共享变量并尝试修改它，最终的结果可能不是预期的。

• 死锁（Deadlock）：当多个线程互相等待对方释放资源时，会导致所有线程都无法继续执行。这种情况通常发生在两个或多个线程在没有适当的控制下相互持有锁时。

• 资源饥饿（Starvation）：当线程永远无法获得所需的资源而导致的状态，通常是因为系统中某些线程总是优先获得执行的机会，而其他线程始终没有机会执行。

为了避免这些问题，我们需要使用线程同步技术来确保对共享资源的访问是有序的。

4.2 线程同步技术

4.2.1 使用synchronized关键字

synchronized是Java中最常用的同步机制，它可以修饰方法或代码块，保证同一时刻只有一个线程可以访问该代码块或方法。

1. 同步方法

在方法声明上使用synchronized关键字，可以让一个线程在执行该方法时获得该对象的锁，其他线程只能等待当前线程执行完毕。

public class Counter {private int count = 0;// 使用synchronized关键字来确保线程安全public synchronized void increment() {count++;}public synchronized int getCount() {return count;}
}public class SynchronizedExample {public static void main(String[] args) {Counter counter = new Counter();// 创建多个线程来进行并发操作for (int i = 0; i < 1000; i++) {new Thread(() -> {counter.increment();}).start();}}
}

在上面的代码中，increment()和getCount()方法都是使用synchronized修饰的，保证了在任一时刻只有一个线程能够进入这两个方法，从而避免了数据不一致的情况。

2. 同步代码块

除了修饰整个方法，synchronized还可以修饰代码块，这样可以将同步控制的范围缩小到关键代码部分，从而提高性能。

public class Counter {private int count = 0;public void increment() {synchronized (this) { // 使用同步代码块count++;}}public int getCount() {return count;}
}

在这个例子中，只有count++操作是被同步的，而其他操作不会受到影响。这样可以减少同步开销，提高程序的效率。

4.2.2 使用Lock接口

Java 5引入了java.util.concurrent.locks.Lock接口，它提供了比synchronized更加灵活和高效的锁机制。Lock接口的实现类包括ReentrantLock、ReentrantReadWriteLock等。与synchronized相比，Lock提供了更细粒度的控制，例如尝试获取锁、定时获取锁、锁的公平性等。

1. 使用ReentrantLock

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;public class Counter {private int count = 0;private final Lock lock = new ReentrantLock();public void increment() {lock.lock(); // 获取锁try {count++;} finally {lock.unlock(); // 释放锁}}public int getCount() {return count;}
}

在这个例子中，我们使用ReentrantLock来代替synchronized，并且手动管理锁的获取和释放。这样，代码执行时能够确保线程安全，并且可以避免死锁的风险。

2. 公平锁

ReentrantLock支持公平锁和非公平锁。公平锁指的是锁的获取遵循先到先得的原则，而非公平锁则可能让等待时间较长的线程被跳过。默认情况下，ReentrantLock是非公平的，但可以通过构造函数显式指定公平锁。

Lock lock = new ReentrantLock(true); // 公平锁

4.2.3 使用Atomic类

Java的java.util.concurrent.atomic包提供了一些原子类（如AtomicInteger、AtomicLong、AtomicReference等），它们通过CAS（Compare-And-Swap）算法实现了对单一变量的原子操作。通过这些类，多个线程可以并发地对同一变量进行操作，而不需要显式的同步。

import java.util.concurrent.atomic.AtomicInteger;public class Counter {private AtomicInteger count = new AtomicInteger(0);public void increment() {count.incrementAndGet(); // 使用原子操作}public int getCount() {return count.get();}
}

在这个例子中，AtomicInteger提供了线程安全的递增操作，避免了手动使用synchronized进行同步的复杂性。

4.2.4 使用volatile关键字

volatile是Java中的一个轻量级同步机制，确保线程对共享变量的读取和写入是直接从主内存中进行，而不是从线程的工作内存中缓存。volatile常用于标志位的共享，以确保多个线程之间的数据一致性。

public class SharedFlag {private volatile boolean flag = false;public void setFlagTrue() {flag = true;}public boolean checkFlag() {return flag;}
}

volatile关键字不适合用于复杂的数据共享场景（例如递增、递减等），但对于简单的标志位，使用volatile可以避免不必要的同步开销。

4.3 线程安全的容器和集合

Java还提供了一些线程安全的集合类，它们可以帮助开发者在多线程环境下安全地操作集合。这些集合类大多位于java.util.concurrent包中，如ConcurrentHashMap、CopyOnWriteArrayList等。

4.3.1 ConcurrentHashMap

ConcurrentHashMap是一个线程安全的哈希表，它在设计上将整个哈希表划分为多个段，每个段可以独立进行锁操作，从而提高了并发性。与Hashtable相比，ConcurrentHashMap在并发场景下性能更好。

import java.util.concurrent.ConcurrentHashMap;public class ConcurrentHashMapExample {public static void main(String[] args) {ConcurrentHashMap<String, Integer> map = new ConcurrentHashMap<>();map.put("apple", 1);map.put("banana", 2);// 线程安全的操作System.out.println(map.get("apple"));}
}

4.3.2 CopyOnWriteArrayList

CopyOnWriteArrayList是线程安全的List实现，它的主要特点是每次修改集合时，都会复制一个新的数组，因此它适用于读多写少的场景。

import java.util.concurrent.CopyOnWriteArrayList;public class CopyOnWriteArrayListExample {public static void main(String[] args) {CopyOnWriteArrayList<String> list = new CopyOnWriteArrayList<>();list.add("apple");list.add("banana");// 线程安全的操作System.out.println(list.get(0));}
}

CopyOnWriteArrayList特别适合于读操作非常频繁，而写操作相对较少的场景，避免了多线程访问时的竞争问题。

4.4 死锁避免与调度

死锁是多线程程序中最常见的问题之一。死锁通常发生在多个线程同时持有资源并互相等待对方释放资源的情况下。为避免死锁，可以采取以下措施：

• 避免嵌套锁：尽量避免线程在持有一个锁的情况下，再去请求其他锁。
• 加锁顺序：所有线程获取锁的顺序必须相同，以避免死锁的发生。
• 使用tryLock()：ReentrantLock提供了tryLock()方法，它允许尝试获取锁，如果未能成功获取锁，可以选择继续执行或尝试其他操作，避免线程长时间等待。

4.5 总结

线程安全是并发编程中的关键问题，保证线程安全的策略有很多种，包括使用synchronized关键字、Lock接口、原子操作类以及线程安全的容器等。通过选择适合的同步工具，我们可以有效避免并发问题，如竞态条件、死锁等，确保程序在高并发环境下的稳定性和正确性。

线程安全不仅仅是一个技术问题，还是设计问题。在设计并发程序时，除了选择合适的同步机制外，还应合理考虑程序的结构与架构，确保系统在并发高效的同时能够避免潜在的并发错误。

五. 结语

经过本篇文章的学习，我们对Java线程的创建和生命周期有了更深入的理解。掌握线程的相关概念和操作，对于提升应用程序的性能和响应能力至关重要。希望你能在实际开发中灵活运用这些知识，成为一名优秀的Java开发者。