S12L03 - 通过继承线程类创建线程的继续

html

通过扩展Thread类在Java中创建线程
目录

介绍...................................................1
理解多线程..................3
通过扩展Thread类创建线程............................................................................................................................6

重写 run() 方法............7
在线程中处理异常..........10


启动和管理线程................13

使用 start() 方法与 run() 方法......................................................................................14
测量处理时间..................17


通过多线程提升性能............................................................................................20
结论.......................................................24
附加资源...................................25

---
介绍
欢迎阅读这本关于通过扩展Thread类在Java中创建线程的全面指南。在Java编程的世界中，多线程是一个基本概念，能够提升应用程序的性能和响应能力。本电子书深入探讨了多线程的细微差别，重点是通过扩展Thread类来创建高效且并发的应用程序。
涵盖的关键点

多线程基础：理解多线程的重要性和目的。
创建线程：通过扩展Thread类的逐步指南。
异常处理：在线程中管理异常。
性能优化：使用多线程提升应用程序性能的技术。
实用示例：真实场景和代码解释。

目的和重要性
多线程允许Java应用程序同时执行多个操作，从而提升效率和用户体验。无论您是初学者还是具有基本知识的开发者，掌握多线程对于构建稳健和高性能的应用程序至关重要。
多线程的优缺点


优点
缺点


增强应用程序性能
代码管理复杂性增加


改善响应性和用户体验
潜在的并发问题（例如，竞争条件）


高效的资源利用
调试和测试更具挑战性


能够同时处理多个任务
更高的内存消耗


何时及在哪里使用多线程
多线程在任务可以并发执行且不会影响应用程序逻辑的场景中非常理想。常见的用例包括：

Web服务器：同时处理多个客户端请求。
GUI应用程序：在执行后台任务时确保用户界面保持响应。
实时数据处理：高效管理持续的数据流。

---
理解多线程
在深入通过扩展Thread类创建线程之前，理解多线程的基本概念及其在Java编程中的重要性是至关重要的。
什么是多线程？
多线程是Java的一项功能，允许同时执行两个或更多线程，以最大化CPU的利用率。每个线程独立运行，在应用程序中执行特定任务。
多线程的好处

提高性能：多个线程可以同时执行任务，减少总执行时间。
更好的资源利用：通过并行处理多个操作，高效使用CPU资源。
增强响应性：即使在进行密集处理时，应用程序仍对用户交互保持响应。

关键概念

Thread：Java虚拟机（JVM）可管理的最小处理单元。
Runnable接口：一个功能性接口，定义了单一的run()方法，表示线程要执行的任务。
并发性：应用程序同时执行多个任务的能力。

---
通过扩展Thread类创建线程
在Java中创建线程的主要方法之一是通过扩展Thread类。这种方法涉及创建一个子类，并重写run()方法，其中包含线程将要执行的代码。
逐步指南

创建Thread的子类:

        



		
		
			
			
Java
			
			public class MyCounter extends Thread {
    // Override the run method
    @Override
    public void run() {
        // 线程执行的任务
    }
}
			
				
					
				
					1
2
3
4
5
6
7
				
						public class MyCounter extends Thread {
    // Override the run method
    @Override
    public void run() {
        // 线程执行的任务
    }
}
					
				
			
		


    
重写run()方法:
run()方法是线程的入口点。当线程使用start()方法启动时，JVM在单独的调用栈中调用run()方法。

实例化并启动线程:

        



		
		
			
			
Java
			
			public class Main {
    public static void main(String[] args) {
        MyCounter counter = new MyCounter();
        counter.start(); // 启动线程
    }
}
			
				
					
				
					1
2
3
4
5
6
				
						public class Main {
    public static void main(String[] args) {
        MyCounter counter = new MyCounter();
        counter.start(); // 启动线程
    }
}
					
				
			
		


    

示例：在单独的线程中计数
让我们来看一个示例，创建一个线程与主线程并行计数。
代码实现




		
		
			
			
Java
			
			// MyCounter.java
public class MyCounter extends Thread {
    @Override
    public void run() {
        try {
            countMe();
        } catch (InterruptedException e) {
            System.out.println("Thread interrupted: " + e.getMessage());
        }
    }

    public void countMe() throws InterruptedException {
        for (int i = 1; i <= 5; i++) {
            System.out.println("Counting: " + i);
            Thread.sleep(1000); // 睡眠1秒
        }
    }
}
			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
				
						// MyCounter.java
public class MyCounter extends Thread {
    @Override
    public void run() {
        try {
            countMe();
        } catch (InterruptedException e) {
            System.out.println("Thread interrupted: " + e.getMessage());
        }
    }
 
    public void countMe() throws InterruptedException {
        for (int i = 1; i <= 5; i++) {
            System.out.println("Counting: " + i);
            Thread.sleep(1000); // 睡眠1秒
        }
    }
}
					
				
			
		






		
		
			
			
Java
			
			// Main.java
public class Main {
    public static void main(String[] args) {
        MyCounter counter = new MyCounter();
        counter.start(); // 启动计数线程

        for (int i = 1; i <= 5; i++) {
            System.out.println("Main thread: " + i);
            try {
                Thread.sleep(500); // 睡眠0.5秒
            } catch (InterruptedException e) {
                System.out.println("Main thread interrupted: " + e.getMessage());
            }
        }
    }
}
			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
				
						// Main.java
public class Main {
    public static void main(String[] args) {
        MyCounter counter = new MyCounter();
        counter.start(); // 启动计数线程
 
        for (int i = 1; i <= 5; i++) {
            System.out.println("Main thread: " + i);
            try {
                Thread.sleep(500); // 睡眠0.5秒
            } catch (InterruptedException e) {
                System.out.println("Main thread interrupted: " + e.getMessage());
            }
        }
    }
}
					
				
			
		


解释

MyCounter 类：扩展Thread类并重写run()方法。countMe()方法从1计数到5，在每次计数之间暂停1秒。
Main 类：创建MyCounter的实例，并使用start()方法启动线程。同时，它运行自己的循环，每0.5秒打印一次消息。

输出




		
		
			
			
Java
			
			Main thread: 1
Counting: 1
Main thread: 2
Counting: 2
Main thread: 3
Counting: 3
Main thread: 4
Counting: 4
Main thread: 5
Counting: 5
			
				
					
				
					1
2
3
4
5
6
7
8
9
10
				
						Main thread: 1
Counting: 1
Main thread: 2
Counting: 2
Main thread: 3
Counting: 3
Main thread: 4
Counting: 4
Main thread: 5
Counting: 5
					
				
			
		


注意：由于线程的并发性，输出的确切顺序可能会有所不同。
---
重写 run() 方法
run()方法是线程执行的核心。当线程使用start()方法启动时，JVM在单独的调用栈中调用run()方法。
重写 run() 的重要性
重写run()方法允许您定义线程将执行的特定任务。确保run()方法包含用于并发执行的逻辑是至关重要的。
示例：run()中的自定义任务




		
		
			
			
Java
			
			public class DataProcessor extends Thread {
    @Override
    public void run() {
        System.out.println("Data processing started.");
        // 执行数据处理任务
        System.out.println("Data processing completed.");
    }
}
			
				
					
				
					1
2
3
4
5
6
7
8
				
						public class DataProcessor extends Thread {
    @Override
    public void run() {
        System.out.println("Data processing started.");
        // 执行数据处理任务
        System.out.println("Data processing completed.");
    }
}
					
				
			
		


在上述示例中，DataProcessor线程在处理数据前后打印消息，模拟数据处理任务。
---
在线程中处理异常
在处理线程时，特别是在处理像InterruptedException这样的受检异常的方法时，适当地处理异常以防止线程意外终止是至关重要的。
常见异常：InterruptedException
InterruptedException发生在一个线程正在睡眠、等待或以其他方式暂停时，另一个线程中断了它。
处理异常的策略

Try-Catch 块:

        



		
		
			
			
Java
			
			@Override
public void run() {
    try {
        riskyOperation();
    } catch (InterruptedException e) {
        System.out.println("Thread interrupted: " + e.getMessage());
    }
}
			
				
					
				
					1
2
3
4
5
6
7
8
				
						@Override
public void run() {
    try {
        riskyOperation();
    } catch (InterruptedException e) {
        System.out.println("Thread interrupted: " + e.getMessage());
    }
}
					
				
			
		


    
抛出异常:
        run()方法不能声明受检异常，因此抛出异常受到限制。因此，使用try-catch块是首选方法。


示例：处理 InterruptedException




		
		
			
			
Java
			
			public class SafeCounter extends Thread {
    @Override
    public void run() {
        try {
            countSafely();
        } catch (InterruptedException e) {
            System.out.println("Counter thread interrupted: " + e.getMessage());
        }
    }

    public void countSafely() throws InterruptedException {
        for (int i = 1; i <= 10; i++) {
            System.out.println("Safe Counting: " + i);
            Thread.sleep(1000); // 睡眠1秒
        }
    }
}
			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
				
						public class SafeCounter extends Thread {
    @Override
    public void run() {
        try {
            countSafely();
        } catch (InterruptedException e) {
            System.out.println("Counter thread interrupted: " + e.getMessage());
        }
    }
 
    public void countSafely() throws InterruptedException {
        for (int i = 1; i <= 10; i++) {
            System.out.println("Safe Counting: " + i);
            Thread.sleep(1000); // 睡眠1秒
        }
    }
}
					
				
			
		


在此示例中，SafeCounter类在run()方法中处理InterruptedException，确保线程能够优雅地管理中断。
---
启动和管理线程
通过扩展Thread类创建线程只是开始。正确地启动和管理线程对实现真正的多线程和优化性能至关重要。
使用 start() 方法与 run() 方法
在处理线程时，理解start()和run()方法之间的区别至关重要。
start() 方法

目的：启动新的执行线程。
行为：为线程创建新的调用栈，并内部调用run()方法。
使用方法：始终使用start()方法并发执行线程。

run() 方法

目的：包含线程将执行的代码。
行为：如果直接调用，将在当前线程的调用栈中执行run()方法。
使用方法：如果希望并发执行，不要直接调用run()方法。

示例展示区别




		
		
			
			
Java
			
			public class ThreadExample extends Thread {
    @Override
    public void run() {
        System.out.println("Thread is running.");
    }
}

public class Main {
    public static void main(String[] args) {
        ThreadExample thread = new ThreadExample();

        System.out.println("Calling run():");
        thread.run(); // 在主线程中运行

        System.out.println("Calling start():");
        thread.start(); // 在单独的线程中运行
    }
}
			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
				
						public class ThreadExample extends Thread {
    @Override
    public void run() {
        System.out.println("Thread is running.");
    }
}
 
public class Main {
    public static void main(String[] args) {
        ThreadExample thread = new ThreadExample();
 
        System.out.println("Calling run():");
        thread.run(); // 在主线程中运行
 
        System.out.println("Calling start():");
        thread.start(); // 在单独的线程中运行
    }
}
					
				
			
		


输出




		
		
			
			
Java
			
			Calling run():
Thread is running.
Calling start():
Thread is running.
			
				
					
				
					1
2
3
4
				
						Calling run():
Thread is running.
Calling start():
Thread is running.
					
				
			
		


注意：尽管输出相似，调用run()在主线程中执行，而start()则在新的线程中运行。
测量处理时间
测量执行任务所需的时间可以提供多线程性能优势的洞察。
示例：比较单线程和多线程执行




		
		
			
			
Java
			
			public class PerformanceTest {
    public static void main(String[] args) {
        long startTime = System.currentTimeMillis();

        // 单线程执行
        for (int i = 0; i < 5; i++) {
            performTask();
        }

        long singleThreadTime = System.currentTimeMillis() - startTime;
        System.out.println("单线程执行时间: " + singleThreadTime + "ms");

        // 多线程执行
        startTime = System.currentTimeMillis();
        for (int i = 0; i < 5; i++) {
            new Thread(() -> performTask()).start();
        }

        long multiThreadTime = System.currentTimeMillis() - startTime;
        System.out.println("多线程执行时间: " + multiThreadTime + "ms");
    }

    public static void performTask() {
        try {
            Thread.sleep(1000); // 模拟任务耗时1秒
            System.out.println("任务由 " + Thread.currentThread().getName() + " 完成");
        } catch (InterruptedException e) {
            System.out.println("任务中断。");
        }
    }
}
			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
				
						public class PerformanceTest {
    public static void main(String[] args) {
        long startTime = System.currentTimeMillis();
 
        // 单线程执行
        for (int i = 0; i < 5; i++) {
            performTask();
        }
 
        long singleThreadTime = System.currentTimeMillis() - startTime;
        System.out.println("单线程执行时间: " + singleThreadTime + "ms");
 
        // 多线程执行
        startTime = System.currentTimeMillis();
        for (int i = 0; i < 5; i++) {
            new Thread(() -> performTask()).start();
        }
 
        long multiThreadTime = System.currentTimeMillis() - startTime;
        System.out.println("多线程执行时间: " + multiThreadTime + "ms");
    }
 
    public static void performTask() {
        try {
            Thread.sleep(1000); // 模拟任务耗时1秒
            System.out.println("任务由 " + Thread.currentThread().getName() + " 完成");
        } catch (InterruptedException e) {
            System.out.println("任务中断。");
        }
    }
}
					
				
			
		


输出




		
		
			
			
Java
			
			单线程执行时间: 5005ms
任务由 Thread-0 完成
任务由 Thread-1 完成
任务由 Thread-2 完成
任务由 Thread-3 完成
任务由 Thread-4 完成
多线程执行时间: 10ms
任务由 Thread-5 完成
任务由 Thread-6 完成
任务由 Thread-7 完成
任务由 Thread-8 完成
任务由 Thread-9 完成
			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
				
						单线程执行时间: 5005ms
任务由 Thread-0 完成
任务由 Thread-1 完成
任务由 Thread-2 完成
任务由 Thread-3 完成
任务由 Thread-4 完成
多线程执行时间: 10ms
任务由 Thread-5 完成
任务由 Thread-6 完成
任务由 Thread-7 完成
任务由 Thread-8 完成
任务由 Thread-9 完成
					
				
			
		


解释

单线程执行：每个任务依次执行，总执行时间与任务数量成正比。
多线程执行：所有任务几乎同时启动，大幅减少总执行时间。

启动线程的最佳实践

始终使用start()进行并发执行：为了利用多线程，始终使用start()方法启动线程。
避免重写start()方法：除非必要，避免重写start()方法，以防止意外行为。
管理线程生命周期：正确处理线程终止和资源管理，以防止内存泄漏并确保应用程序稳定。

---
通过多线程提升性能
多线程是优化应用程序性能的强大工具。通过并发执行多个线程，应用程序可以更高效地处理更多任务，从而实现更快的处理时间和更高的用户满意度。
真实场景：Web服务器处理多个请求
考虑一个需要同时处理多个客户端请求的Web服务器。使用多线程，服务器可以在单独的线程中处理每个请求，确保一个缓慢的请求不会阻塞其他请求。
优点

减少延迟：每个请求独立处理，客户端更快地接收响应。
可扩展性：服务器可以在不降低性能的情况下处理更多的同时连接。
资源优化：通过跨多个线程分配任务，高效利用CPU和内存资源。

实用示例：模拟多线程服务器




		
		
			
			
Java
			
			public class ClientHandler extends Thread {
    private String clientName;

    public ClientHandler(String clientName) {
        this.clientName = clientName;
    }

    @Override
    public void run() {
        try {
            System.out.println(clientName + " connected.");
            Thread.sleep(2000); // 模拟处理时间
            System.out.println(clientName + " request processed.");
        } catch (InterruptedException e) {
            System.out.println("ClientHandler interrupted: " + e.getMessage());
        }
    }
}

public class ServerSimulation {
    public static void main(String[] args) {
        String[] clients = {"Client1", "Client2", "Client3"};

        for (String client : clients) {
            ClientHandler handler = new ClientHandler(client);
            handler.start();
        }
    }
}
			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
				
						public class ClientHandler extends Thread {
    private String clientName;
 
    public ClientHandler(String clientName) {
        this.clientName = clientName;
    }
 
    @Override
    public void run() {
        try {
            System.out.println(clientName + " connected.");
            Thread.sleep(2000); // 模拟处理时间
            System.out.println(clientName + " request processed.");
        } catch (InterruptedException e) {
            System.out.println("ClientHandler interrupted: " + e.getMessage());
        }
    }
}
 
public class ServerSimulation {
    public static void main(String[] args) {
        String[] clients = {"Client1", "Client2", "Client3"};
 
        for (String client : clients) {
            ClientHandler handler = new ClientHandler(client);
            handler.start();
        }
    }
}
					
				
			
		


输出




		
		
			
			
Java
			
			Client1 connected.
Client2 connected.
Client3 connected.
Client1 request processed.
Client2 request processed.
Client3 request processed.
			
				
					
				
					1
2
3
4
5
6
				
						Client1 connected.
Client2 connected.
Client3 connected.
Client1 request processed.
Client2 request processed.
Client3 request processed.
					
				
			
		


解释
每个ClientHandler线程模拟处理客户端请求，使服务器能够并发处理多个客户端，而无需等待一个请求完成后再开始下一个。
性能指标与分析
为了量化多线程带来的性能提升，分析以下关键指标是必不可少的：

执行时间：执行任务所需的总时间。
吞吐量：单位时间内完成的任务数量。
资源利用率：执行期间CPU和内存的使用情况。

通过在单线程和多线程环境中比较这些指标，开发者可以评估其多线程实现的有效性。
---
结论
在本电子书中，我们探讨了通过扩展Thread类在Java中创建线程的复杂性，这是多线程编程的一个基本方面。理解如何有效地实现和管理线程对于开发高性能、响应迅速的应用程序至关重要。
关键要点

多线程提升性能：线程的并发执行带来更快和更高效的应用程序。
扩展Thread类：通过重写run()方法创建线程的简单方法。
异常处理：在线程中正确管理异常确保应用程序的稳定性。
Start vs Run：使用start()方法对于真正的多线程执行至关重要。
实用应用：真实场景展示了多线程在Web服务器等应用中的实际好处。

最后的想法
掌握多线程使开发者能够构建能够无缝处理复杂任务的应用程序，为用户提供更流畅、更高效的体验。随着您在Java编程旅程的继续，利用多线程无疑将成为您工具箱中宝贵的技能。
SEO关键词: Java multithreading, create threads in Java, extend Thread class, Java concurrency, multithreaded application, Java Thread run method, handling InterruptedException, Java performance optimization, start vs run in Java, Java Thread example
---
附加资源

Java文档关于Threads
Java中的并发性
Joshua Bloch的Effective Java
Java多线程教程
理解Java线程

---
注意：本文由AI生成。
优点	缺点
增强应用程序性能	代码管理复杂性增加
改善响应性和用户体验	潜在的并发问题（例如，竞争条件）
高效的资源利用	调试和测试更具挑战性
能够同时处理多个任务	更高的内存消耗