目录
一、举例说明Thread、Runnable、线程池的实现过程
一、举例说明Thread、Runnable、线程池的实现过程
1、通过继承Thread类创建并执行线程
public class MyThread extends Thread {
@Override
public void run() {
// 线程执行的代码逻辑
System.out.println("Thread is running...");
}
}
public class Main {
public static void main(String[] args) {
MyThread myThread = new MyThread(); // 创建线程对象
myThread.start(); // 启动线程
}
}在上面的示例中，定义了一个MyThread类，它继承了Thread类。在run()方法中，定义了线程要执行的代码逻辑。在主程序中，我们创建了MyThread对象并调用start()方法来启动线程。当调用start()方法时，线程会自动调用run()方法来执行线程的逻辑。
2、通过实现Runnable接口创建并执行线程
public class MyRunnable implements Runnable {
@Override
public void run() {
// 线程执行的代码逻辑
System.out.println("Thread is running...");
}
}
public class Main {
public static void main(String[] args) {
Thread thread = new Thread(new MyRunnable()); // 创建线程对象并传入Runnable对象
thread.start(); // 启动线程
}
}3、使用Executor框架
Java的Executor框架提供了一种更高级的方式来管理线程。它提供了一组工厂方法来创建不同类型的Executor，例如Executors.newFixedThreadPool()和Executors.newCachedThreadPool()。这些Executor可以用来创建和执行线程池。下面是一个简单的示例：
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;
public class Main {
public static void main(String[] args) {
ExecutorService executorService = Executors.newFixedThreadPool(5); // 创建一个固定大小的线程池
executorService.submit(() -> { // 提交任务到线程池中执行
System.out.println("Task is running on thread " + Thread.currentThread().getName());
});
executorService.shutdown(); // 关闭线程池
}
}二、三种方法的区别
Thread 类、Runnable 接口和线程池是 Java 中实现多线程的三种常见方式，它们各自有不同的特点和使用场景。
1、Thread 类：
Thread 类是 Java 中的一个内置类，使用 Thread 类实现多线程时，需要继承 Thread 类并重写其 run() 方法，然后创建 Thread 对象并调用其 start() 方法启动线程。这种方式可以实现多线程，但是每个线程都需要创建一个独立的对象，如果线程数量很大，会占用大量的内存空间。
2、Runnable 接口：
Runnable 接口是 Java 中定义的一个接口，它只有一个 run() 方法，用于定义线程执行的代码逻辑。使用 Runnable 接口实现多线程时，需要实现 Runnable 接口并重写其 run() 方法，然后创建一个 Thread 对象并将 Runnable 对象作为参数传递给 Thread 的构造函数，最后调用 Thread 的 start() 方法启动线程。这种方式相比继承 Thread 类更加灵活，因为多个线程可以共享同一个 Runnable 对象，可以节省内存空间。
3、线程池
线程池是一种更加高效的多线程实现方式。它通过预先创建一定数量的线程并保存在内存中，避免了频繁地创建和销毁线程对象，提高了线程的复用性。使用线程池实现多线程时，需要创建一个 ExecutorService 对象（可以通过 Executors 类创建），然后调用其 submit() 或 execute() 方法提交任务给线程池执行。这种方式可以更加高效地利用系统资源，减少线程的创建和销毁开销。
三、使用多线程处理多个任务
1、不使用线程池
如果不使用线程池，可以通过创建多个线程对象并手动启动它们来实现多线程，示例如下：
public class Task implements Runnable {
private String taskName;
public Task(String taskName) {
this.taskName = taskName;
}
@Override
public void run() {
// 线程执行的代码逻辑
System.out.println("Task " + taskName + " is running on thread " + Thread.currentThread().getName());
}
}
public class Main {
public static void main(String[] args) {
// 创建多个线程对象
Thread thread1 = new Thread(new Task("Task 1"));
Thread thread2 = new Thread(new Task("Task 2"));
Thread thread3 = new Thread(new Task("Task 3"));
Thread thread4 = new Thread(new Task("Task 4"));
Thread thread5 = new Thread(new Task("Task 5"));
// 启动线程
thread1.start();
thread2.start();
thread3.start();
thread4.start();
thread5.start();
}
}上面示例中，每个线程将独立执行其任务，从而实现多线程的效果。需要注意的是，这种方式需要手动管理线程的生命周期，并且需要注意线程同步和资源共享等问题。因此，在实际开发中，使用线程池更加高效和方便。
2、使用线程池
使用线程池示例如下：
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
public class Task implements Runnable {
private String taskName;
public Task(String taskName) {
this.taskName = taskName;
}
@Override
public void run() {
// 执行任务逻辑
if ("Task 1".equals(taskName)) {
// 任务1的逻辑
System.out.println("Task 1 is running on thread " + Thread.currentThread().getName());
} else if ("Task 2".equals(taskName)) {
// 任务2的逻辑
System.out.println("Task 2 is running on thread " + Thread.currentThread().getName());
} else if ("Task 3".equals(taskName)) {
// 任务3的逻辑
System.out.println("Task 3 is running on thread " + Thread.currentThread().getName());
}
}
}
public class Main {
public static void main(String[] args) {
// 创建线程池
ExecutorService executor = Executors.newFixedThreadPool(3); // 创建一个固定大小的线程池，最多同时运行3个任务
// 创建多个任务对象并提交给线程池执行
executor.submit(new Task("Task 1"));
executor.submit(new Task("Task 2"));
executor.submit(new Task("Task 3"));
// 关闭线程池，不再接受新的任务，但仍会执行已提交的任务
executor.shutdown();
}
}在这个示例中，使用了 ExecutorService 来创建一个线程池，然后通过调用 submit 方法来提交任务给线程池执行。这种方式更加高效，可以复用线程，并且可以通过配置来限制同时运行的线程数量。
四、线程池的处理流程（面试题）
线程池的处理流程主要包括以下几个步骤：
1、任务提交：当任务被提交到线程池时，线程池会首先检查当前是否有可用的线程。如果有，则将任务分派给该线程执行；如果没有，则根据线程池的设置来处理该任务。
2、判断核心线程数：线程池会判断当前的核心线程数是否已满。如果没有满，则创建一个新的核心线程去执行任务。如果已满，则进入下一个流程。
3、判断工作队列：如果工作队列未满，则将新提交的任务存储在工作队列里。如果工作队列已满，则进入下一个流程。
4、判断整个线程池：如果线程池里面的存活线程数已经等于核心线程数，且工作队列已经满了，再会去判断当前线程数是否已经达到最大线程数。如果没有达到，则会创建一个新的非核心线程去执行任务；如果已经达到，则交给饱和策略来处理这个任务。
5、饱和策略：当队列和线程池都满了的时候，再有新的任务到达，就必须要有一种办法来处理新来的任务。拒绝策略在此时发挥作用。具体的策略包括丢弃任务、抛出异常或阻塞当前任务等。
扫一扫
8537
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
