Java核心技术【二十三】多线程编程基础-线程的生命周期-线程的启动、睡眠与销毁

🌟 晋升管理 请关注 技术管理修行

Java多线程编程详细讲解

多线程编程是Java编程中的一个重要部分，它允许程序同时执行多个任务，从而充分利用系统资源，提高程序的执行效率。本文将详细讲解Java多线程编程的关键概念、创建和启动线程的步骤，以及线程生命周期管理的相关内容。通过深入浅出的方式，帮助初学者和有一定基础的开发者更好地理解和掌握多线程编程的原理和应用。

一、多线程编程的关键概念

1. 进程与线程

• 进程 是系统进行资源分配和调度的基本单位，是应用程序的一次动态执行过程。
• 线程 是进程的一个实体，是CPU调度和分派的基本单位，它能够利用进程所拥有的资源。线程自己基本上不拥有系统资源，只拥有一点在运行中必不可少的资源（如程序计数器、一组寄存器和栈），但它可以与同属一个进程的其他线程共享进程所拥有的全部资源。

2. 多线程的优势

• 提高应用程序的响应性：通过多线程技术，可以将耗时的任务分配给后台线程处理，从而避免阻塞主线程，使得用户界面能够及时响应，提升用户体验。
• 提高数据处理效率：多线程能够充分利用多核处理器的并行处理能力，同时执行多个任务，从而显著提高数据处理的速度和效率。
• 改善程序结构：多线程编程使程序的结构更加清晰，可以将不同的任务分配给不同的线程执行，每个线程负责一部分功能，使得程序更易于理解和维护。
• 资源共享与通信：线程之间可以共享进程的资源，这使线程间的通信和数据交换变得更加方便和高效。

3. 线程的生命周期概述

• 新建状态（NEW）：当线程对象被创建时，它处于新建状态。在这个状态下，线程还没有开始执行，只是进行了线程的初始化。
• 就绪状态（RUNNABLE）：当调用线程对象的start()方法后，线程进入就绪状态。在这个状态下，线程已经做好了执行的准备，等待CPU的调度。
• 运行状态（RUNNING）：当线程获取到CPU资源后，它开始执行，并进入运行状态。在这个状态下，线程执行其任务代码。
• 阻塞状态（BLOCKED）：线程在执行过程中，可能会因为某些原因（如等待I/O操作完成、等待获取锁等）而放弃CPU使用权，进入阻塞状态。在阻塞状态下，线程不会执行任何操作，直到它再次进入就绪状态。
• 死亡状态（DEAD）：当线程执行完毕或因为异常而退出时，它进入死亡状态。在这个状态下，线程已经完成了它的生命周期。

1）代码示例：

下面是一个简单的Java多线程编程示例，演示了线程的生命周期：

package java_core_23;

public class ThreadLifecycleExample {  
	  
    public static void main(String[] args) {  
        // 创建线程对象，此时线程处于新建状态  
        Thread thread = new Thread(() -> {  
            // 线程执行的任务代码  
            for (int i = 0; i < 5; i++) {  
                System.out.println("Thread is running: " + i);  
                try {  
                    // 让线程休眠一段时间，模拟阻塞状态  
                    Thread.sleep(1000);  
                } catch (InterruptedException e) {  
                    e.printStackTrace();  
                }  
            }  
        });  
  
        // 调用start()方法，线程进入就绪状态  
        System.out.println("Thread is starting...");  
        thread.start();  
  
        // 主线程继续执行其他任务，而上面的线程在后台运行  
        for (int i = 0; i < 3; i++) {  
            System.out.println("Main thread is running: " + i);  
            try {  
                Thread.sleep(800); // 让主线程也休眠一段时间  
            } catch (InterruptedException e) {  
                e.printStackTrace();  
            }  
        }  
  
        // 当上面的线程执行完毕后，它会自动进入死亡状态  
        System.out.println("Main thread is finished.");  
    }  
}

2）代码运行结果：

以下结果显示了线程的运行流程：

Thread is starting...
Main thread is running: 0
Thread is running: 0
Main thread is running: 1
Thread is running: 1
Main thread is running: 2
Thread is running: 2
Main thread is finished.
Thread is running: 3
Thread is running: 4

二、线程的创建和启动

在Java中，创建和启动线程主要有两种方法：

1. 继承Thread类

1）编写 MyThread 类

• 创建一个继承于 Thread 类的子类。
• 重写 Thread 类的 run() 方法——将此线程执行的操作声明在 run() 中。
• 创建 Thread 类的子类的对象。
• 通过此对象调用 start() 方法。

public class MyThread extends Thread {  
    public void run() {  
        for (int i = 0; i < 5; i++) {  
            System.out.println(Thread.currentThread().getName() + " " + i);  
        }  
    }  
} 

在这个例子中，我们创建了一个 MyThread 类，它继承自 Thread 类，并重写了 run 方法，在 run 方法中，我们打印线程的名称和计数。

2）调用启动线程

public class Main {  
    public static void main(String[] args) { 
    	//继承Thread类的方式 
        MyThread t1 = new MyThread();  
        t1.start(); // 启动线程  
 
        for (int i = 0; i < 5; i++) {  
            System.out.println(Thread.currentThread().getName() + " " + i);  
        }  
    }  
} 

在 main 方法中，我们创建了 MyThread 的一个实例，并调用其 start 方法来启动线程，为了展示不同线程执行的效果，在调用类中也同样打印线程的名称和计数。

3）执行结果：

main 0
main 1
Thread-0 0
main 2
main 3
Thread-0 1
main 4
Thread-0 2
Thread-0 3
Thread-0 4

可以看到，两个线程是 交替执行。

2. 实现Runnable接口

1）创建 MyRunnable 类

• 创建一个实现了 Runnable 接口的类。
• 实现类去实现 Runnable 中的抽象方法：run()。
• 创建实现类的对象。
• 将此对象作为参数传递到 Thread 类的构造器中，创建 Thread 类的对象。
• 通过 Thread 类的对象调用 start()。

public class MyRunnable implements Runnable {  
    public void run() {  
        for (int i = 0; i < 5; i++) {  
            System.out.println(Thread.currentThread().getName() + " " + i);  
        }  
    }  
} 

在这个例子中，我们创建了一个 MyRunnable 类，它实现了 Runnable 接口，并重写了 run 方法。在 main 方法中，我们创建了 MyRunnable 的一个实例，并将其作为参数传递给 Thread 类的构造器，然后调用 start 方法来启动线程。

2）调用启动线程

public class Main {  
    public static void main(String[] args) {  
    	//实现Runnable接口的方式
        MyRunnable myRunnable = new MyRunnable();  
        Thread thread = new Thread(myRunnable);  
        thread.start(); // 启动线程  
 
        for (int i = 0; i < 5; i++) {  
            System.out.println(Thread.currentThread().getName() + " " + i);  
        }  
    }  
}

3）执行结果：

main 0
main 1
Thread-0 0
main 2
main 3
Thread-0 1
main 4
Thread-0 2
Thread-0 3
Thread-0 4

三、Java提供了多种方法来管理线程的生命周期

1. start() 方法

start() 方法是用来启动一个新线程的。调用 start() 方法后，JVM会调用线程的 run() 方法。

class MyThread extends Thread {  
    public void run() {  
        System.out.println("线程运行中...");  
    }  
}  
  
public class Test {  
    public static void main(String[] args) {  
        MyThread t = new MyThread();  
        t.start(); // 启动线程  
    }  
}

2. run() 方法

run() 方法是线程的主体，包含了线程要执行的代码。当你创建一个线程对象时，你需要重写这个方法以定义线程的行为。

class MyThread extends Thread {  
    public void run() {  
        System.out.println("线程运行中...");  
    }  
}

3. sleep(long millis) 方法

sleep() 方法可以使当前线程暂停执行一段时间，参数 millis 指定了暂停的时间，单位是毫秒。

public class TestSleep {  
    public static void main(String[] args) {  
        try {  
            System.out.println("当前时间: " + System.currentTimeMillis());  
            Thread.sleep(2000); // 线程暂停2秒  
            System.out.println("2秒后: " + System.currentTimeMillis());  
        } catch (InterruptedException e) {  
            e.printStackTrace();  
        }  
    }  
}

4. join() 方法

join() 方法用于等待当前线程结束。如果某个线程在另一个线程 t 上调用 t.join()，此线程将被挂起，直到线程 t 结束。

1）在两条打印语句中睡眠两秒：

class MyThread1 extends Thread {  
    public void run() {  
        try {  
            System.out.println("线程开始运行..." + System.currentTimeMillis());  
            Thread.sleep(2000);  
            System.out.println("线程结束运行..." + System.currentTimeMillis());  
        } catch (InterruptedException e) {  
            e.printStackTrace();  
        }  
    }  
}  

2）启动线程后，加入 t.join 语句，等待线程 t 结束

public class TestJoin {  
    public static void main(String[] args) {  
        MyThread1 t = new MyThread1();  
        t.start();  
        try {  
            t.join(); // 等待线程t结束  
            System.out.println("主线程继续运行...");  
        } catch (InterruptedException e) {  
            e.printStackTrace();  
        }  
    }  
}

3）输出结果如下：

线程开始运行...1721101549836
线程结束运行...1721101551842
主线程继续运行...

5. stop() 方法

stop() 方法是用来立即停止线程的执行。但是，这个方法是不安全的，因为它会在任何时候停止线程，可能会导致数据不一致的问题。因此，不推荐使用。

6. destroy() 方法

destroy() 方法并不是 Thread 类的一部分，实际上Java并没有提供destroy() 方法来销毁线程。一旦线程启动，它将执行直到 run() 方法完成。

结束语

综上所述，Java多线程编程不仅是Java编程中的重要组成部分，也是提升程序性能和实现高效任务处理的关键技术。通过本文的详细讲解，我们深入了解了多线程的关键概念、线程的生命周期管理，以及线程的创建和启动步骤。希望这些内容能够帮助初学者和有一定基础的开发者更好地掌握多线程编程的原理和应用，从而在实际开发中更加灵活地运用多线程技术，提升程序的执行效率和响应能力。

简单动作，深刻联结。在这技术海洋，我备好舟，等你扬帆。启航吧！
🌟点击【关注】，解锁定期的技术惊喜，让灵感与知识的源泉不断涌动。
👍一个【点赞】，如同心照不宣的默契，是我们共同语言的闪亮印记。
📚【收藏】好文，搭建你的专属智慧库，让每次回望都能照亮新知之路。

---