Java 并发编程面试题——创建和结束线程

- 日理万妓 2023-10-10 18:24 15阅读 0赞

#### 目录 ####

*  1.创建线程的方式有哪几种？
 *   *  1.1.继承 Thread 类，并重写 run 方法
     *  1.2.实现 Runnable 接口中的 run 方法
     *  1.3.实现 Callable 接口的 call() 方法，并结合来 Future 实现
     *  1.4.通过线程池创建
 *  2.上述创建线程的方式有什么优缺点？
 *  3.Runnable 和 Callable 有什么区别？
 *  4.怎么获取子线程的返回值？
 *  5.子线程抛异常，主线程 try-catch 是否可以获取到异常？
 *  6.怎样安全地结束一个线程？使用 stop() 方法直接结束线程会有什么影响？

## 1.创建线程的方式有哪几种？ ##

### 1.1.继承 Thread 类，并重写 run 方法 ###

（1）具体步骤如下：

*  定义类 `MyThread` 来继承 Thread 类，重写 run 方法；
 *  然后创建该类的对象，并调用 start() 方法启动线程。

public class Demo {
        
        public static class MyThread extends Thread {
        
            @Override
            public void run() {
        
                System.out.println("MyThread");
            }
        }
        
        public static void main(String[] args) {
        
            Thread myThread = new MyThread();
            myThread.start();
        }
    }

（2）注意要调用 start() 方法后，该线程才算启动！我们在程序里面调用了start() 方法后，虚拟机会先为我们创建⼀个线程，然后等到这个线程第⼀次得到时间片时再调用 run() 方法。**注意不可多次调用 start() 方法。在第一次调用start() 方法后，再次调用start() 方法会抛出异常。**

（3）也可以直接使用 `Thread` 类来创建线程：

@Slf4j
    public class Demo {
        
        public static void main(String[] args) {
        
        	//创建线程对象
            Thread t = new Thread(() -> {
        
            	//要执行的任务
                log.debug("running");
            });
            //为线程设置名称，也可以在创建线程时直接指定，例如 Thread t1 = new Thread("t1") {...};
            t.setName("t1");
            //启动线程
            t.start();
            
    		log.debug("running");
            //注：上面两条日志打印语句的顺序不固定
        }
    }

### 1.2.实现 Runnable 接口中的 run 方法 ###

（1）具体步骤如下：

*  定义一个类 `MyThread` 实现 Runnable 接口，并实现 run 方法；
 *  然后创建该类的对象，并将其作为 target 传入 Thread 的构造函数中，需要注意的是也可以使用 lambda 表达式来进行简化；
 *  最后调用 start() 方法启动线程。

Runnable 接口 (JDK 1.8 +) 代码如下：

@FunctionalInterface
    public interface Runnable {
        
    	public abstract void run(); 
    }

可以看到 Runnable 是⼀个**函数式接口**，这意味着我们可以使用 Java 8 的函数式编程来简化代码。示例代码如下：

public class Demo {
        
        public static class MyThread implements Runnable {
        
            @Override
            public void run() {
        
                System.out.println("MyThread");
            }
        }
        
        public static void main(String[] args) {
        
            new Thread(new MyThread()).start();
            
            //或者使用 Java 8 函数式编程，可以省略 MyThread 类
            new Thread(() -> {
        
                System.out.println("Java 8 匿名内部类");
            }).start();
        }
    }

（2）也可以通过如下方式创建线程：

@Slf4j
    public class Demo {
        
        public static void main(String[] args) {
        
            Runnable r = new Runnable() {
        
                @Override
                public void run() {
        
                    log.debug("running");
                }
            };
            
            Thread t = new Thread(r, "t1");
            t.start();
            
            log.debug("running");
        }
    }

Java 8 以后可以使用 lambda 精简代码（本代码中的前提是接口中只有一个抽象方法）：

public class Demo {
        
        public static void main(String[] args) {
        
            Runnable r = () -> {
        
                log.debug("running");
            };
            Thread t = new Thread(r, "t1");
            t.start();
            log.debug("running");
        }
    }

### 1.3.实现 Callable 接口的 call() 方法，并结合来 Future 实现 ###

（1）具体步骤如下：

*  定义一个 Callable 的实现类 `Task`，并实现 call() 方法（有返回值）；
 *  将 Task 类对象作为参数传入到 FutureTask 的构造函数中；
 *  再把 FutureTask 作为 target 传入到 Thread 的构造函数中，创建 Thread 线程对象，并调用 start() 方法启动线程；
 *  最后通过 FutureTask 的 get 方法来**异步获取线程的执行结果**。

class Task implements Callable<Integer> {
        
        @Override
        public Integer call() throws Exception {
        
            // 模拟计算需要3秒
            Thread.sleep(3000);
            return 2;
        }
        
        public static void main(String[] args) throws ExecutionException, InterruptedException {
        
            FutureTask<Integer> task = new FutureTask<>(new Task());
            new Thread(task).start();
            Integer res = task.get();
            //注意调⽤ get ⽅法会阻塞当前线程，直到得到结果，所以实际编码中建议使⽤可以设置超时时间的重载 get ⽅法
            System.out.println(res);
            System.out.println("end...");
        }
    }

输出结果如下：

2
    end...

（2）此外，**Callable⼀般也可配合线程池工具 ExecutorService 来使用**。这里只介绍 ExecutorService 可以使用 submit 方法来让⼀个 Callable 接口执行。它会返回⼀个 Future，我们后续的程序可以通过这个 Future 的 get 方法得到结果。这里可以看⼀个简单的使用案例：

import java.util.concurrent.*;
    
    class Task implements Callable<Integer> {
        
        @Override
        public Integer call() throws Exception {
        
            // 模拟计算需要⼀秒
            Thread.sleep(1000);
            return 2;
        }
        
        public static void main(String args[]) throws ExecutionException, InterruptedException {
        
            ExecutorService executor = Executors.newCachedThreadPool();
            Task task = new Task();
            Future<Integer> result = executor.submit(task);
            //注意调⽤ get ⽅法会阻塞当前线程，直到得到结果，所以实际编码中建议使⽤可以设置超时时间的重载 get ⽅法。
            System.out.println(result.get());
        }
    }

输出结果同上。

### 1.4.通过线程池创建 ###

使用 `ThreadPoolExecutor` 类的构造函数可以自定义线程池，下面使用参数最全的构造函数来举例：

import com.google.common.util.concurrent.ThreadFactoryBuilder;
    import java.util.concurrent.*;
    
    class Solution {
        
        public static void main(String[] args) throws ExecutionException, InterruptedException {
        
            //自定义线程池
            int corePoolSize = 2;
            int maximumPoolSize = 5;
            long keepAliveTime = 50;
            // keepAliveTime 的单位
            TimeUnit unit = TimeUnit.MICROSECONDS;
            //工作队列 workQueue
            BlockingQueue<Runnable> blockingQueue = new ArrayBlockingQueue<>(3);
            //使用开源框架 guava 提供的 ThreadFactoryBuilder 可以给线程池里的线程自定义名字
            ThreadFactory threadFactory = new ThreadFactoryBuilder().setNameFormat("demo-task-%d").build();
            //饱和策略
            RejectedExecutionHandler handler = new ThreadPoolExecutor.AbortPolicy();
            ThreadPoolExecutor threadsPool = new ThreadPoolExecutor(
                                                 corePoolSize, maximumPoolSize,
                                                 keepAliveTime, unit,
                                                 blockingQueue, threadFactory,
                                                 handler);
            //执行无返回值的任务
            Runnable taskWithoutRet = new Runnable() {
        
                @Override
                public void run() {
        
                    System.out.println(Thread.currentThread().getName() + " is running");
                }
            };
            threadsPool.execute(taskWithoutRet);
        
            //执行有返回值的任务
            FutureTask<Integer> taskWithRet = new FutureTask<>(new Callable<Integer>() {
        
                @Override
                public Integer call() throws Exception {
        
                    System.out.println(Thread.currentThread().getName() + " is running");
                    //线程睡眠 1000 ms
                    Thread.sleep(1000);
                    return 100;
                }
            });
            threadsPool.submit(taskWithRet);
            System.out.println("有返回值的任务的结果为: " + taskWithRet.get());
            
            //关闭线程池
            threadsPool.shutdown();
        }
    }

> ① 有关 `Futrue` 的相关知识可以参考[Java 并发编程面试题——Future][Java _Future]这篇文章。  
> ② 有关**线程池**的相关知识可以参考[Java并发编程面试题——线程池][Java]这篇文章。

## 2.上述创建线程的方式有什么优缺点？ ##

（1）使用继承 Thread 类的方式创建线程：

*  **优点**：线程类只是实现了 Runnable 接口或 Callable 接口，还可以继承其他类。在这种方式下，**多个线程可以共享同一个 target 对象**，所以非常适合多个相同线程来处理同一份资源的情况，从而可以将 CPU、代码和数据分开，形成清晰的模型，**体现了面向对象的思想**。
 *  **缺点**：编程稍微复杂一些，如果要访问当前线程，则必须使用 Thread.currentThread() 方法

（2）采用实现 Runnable、Callable 接口的方式创建线程：

*  **优点**：编写简单，如果需要访问当前线程，则无需使用 Thread.currentThread() 方法，直接使用 this 即可获得当前线程。
 *  **缺点**：线程类已经继承了 Thread 类，所以不能再继承其他父类。

（3）通过线程池来创建线程：

*  **优点**：
    
     *  **降低线程创建和销毁的开销**：线程池中的线程可以被重复利用，避免了频繁创建和销毁线程的开销，从而提高了程序的性能。
     *  **控制并发数**：线程池可以限制并发执行的线程数量，避免系统资源被过度占用，从而提高了程序的稳定性。
     *  **提高响应速度**：线程池中已经存在的线程可以更快地响应任务请求，减少了线程创建和启动的时间，从而提高了程序的响应速度。
 *  **缺点**：
    
     *  线程池本身需要占用一定的系统资源，当线程池中的线程数量过多时，会占用较多的内存和CPU资源。
     *  线程池中的任务队列可能会产生阻塞，当任务队列已满时，新的任务请求需要等待队列中的任务完成才能被处理，从而降低了程序的并发性能。
     *  如果线程池中的线程出现异常或者死循环等问题，可能会导致整个系统的崩溃，因此需要对线程池进行合理的配置和管理。

## 3.Runnable 和 Callable 有什么区别？ ##

Runnable 和 Callable 都是 Java 并发编程中**用于创建线程的接口**，它们的主要区别如下：

*  **规定的方法**：Callable 规定（重写）的方法是 **call()**，Runnable 规定（重写）的方法是 **run()**。
 *  **返回值**：Callable 中的 call() 方法返回一个**泛型类型的结果**，而 Runnable 的 run() 方法**无返回值**。
 *  **抛出异常**：call() 方法可以**抛出异常**，run() 方法**不可以**。
 *  **使用场景**：Callable 接口通常用于执行需要返回结果的复杂任务（异步获取结果），Runnable 接口通常用于执行简单任务。

## 4.怎么获取子线程的返回值？ ##

在 Java 中，获取子线程的返回值有多种方式，如下所示：

*  使用 `Callable` 和 `Future`：`Callable` 是一个带有泛型参数的接口，可以用于定义具有返回值的任务。可以在启动子线程时使用 `Callable`，并将其提交给一个 `ExecutorService`，然后通过 `Future` 对象获取子线程的返回值。

// 创建一个 Callable
       Callable<Integer> task = () -> {
        
           // 执行子线程任务
           return 42;
       };
    
       // 创建 ExecutorService
       ExecutorService executor = Executors.newSingleThreadExecutor();
    
       // 提交 Callable 任务，并获取 Future 对象
       Future<Integer> future = executor.submit(task);
    
       // 等待子线程执行完成并获取返回值
       Integer result = future.get();
    
       // 关闭 ExecutorService
       executor.shutdown();

*  **使用共享变量**：可以在子线程中修改一个共享的变量，并在主线程中通过该变量获取子线程的返回值。需要注意的是，为了确保线程安全，需要采取适当的同步机制（如锁、原子类等）来保护共享变量。

class MyThread extends Thread {
        
           private int result;
    
           public int getResult() {
        
               return result;
           }
    
           @Override
           public void run() {
        
               // 执行子线程任务
               result = 42;
           }
       }
    
       // 创建子线程并启动
       MyThread thread = new MyThread();
       thread.start();
    
       // 等待子线程执行完成
       thread.join();
    
       // 获取子线程的返回值
       int result = thread.getResult();

*  使用 `CompletableFuture`：`CompletableFuture` 是 Java 8 引入的一个强大的异步编程工具，可以用于获取和处理子线程的返回值。

// 创建 CompletableFuture
    CompletableFuture<Integer> future = CompletableFuture.supplyAsync(() -> {
        
        // 执行子线程任务
        return 42;
    });
    
    // 等待子线程执行完成并获取返回值
    Integer result = future.get();

## 5.子线程抛异常，主线程 try-catch 是否可以获取到异常？ ##

（1）在 Java 中，子线程抛出的异常主线程是**无法直接捕获**的。当子线程抛出异常时，主线程是无法感知到异常的，也无法通过常规的 try-catch 块来捕获子线程的异常。这是因为**线程之间是相互独立的，主线程和子线程各自运行在自己的执行上下文中**。子线程的异常只能在子线程的上下文中被捕获和处理，如果没有相应的处理，该异常会导致子线程终止。

（2）然而，可以通过其他方式来获取子线程的异常信息，比如使用 `Thread.UncaughtExceptionHandler` 接口来处理未捕获的异常。你可以通过为子线程设置一个自定义的 `UncaughtExceptionHandler` 来捕获并处理子线程抛出的异常信息。下面是一个示例：

Thread thread = new Thread(() -> {
        
        // 子线程任务
        throw new RuntimeException("子线程抛出异常");
    });
    
    thread.setUncaughtExceptionHandler((t, e) -> {
        
        // 在这里处理子线程抛出的异常
        System.out.println("捕获到异常：" + e.getMessage());
    });
    
    thread.start();

在上面的示例中，我们设置了子线程的`UncaughtExceptionHandler`，当子线程抛出异常时，就会调用指定的处理逻辑来处理异常，我们可以在这里记录、打印或进行其他必要的处理。

（3）总结起来，主线程不能直接捕获子线程抛出的异常，但可以通过设置`UncaughtExceptionHandler`来捕获并处理子线程的未捕获异常。

## 6.怎样安全地结束一个线程？使用 stop() 方法直接结束线程会有什么影响？ ##

（1）在 Java 中，直接调用线程的 `stop()` 方法来结束线程是不安全的，并且已经被废弃。这是因为 `stop()` 方法会**立即终止线程的执行，可能导致线程处于不一致的状态，使得共享资源无法正确释放，或者引发数据不一致等问题**。

（2）如果需要结束一个线程，推荐以下几种安全的方式：

*  **设置退出标志**：使用一个 `volatile` 类型的标志来表示线程是否要结束，并且在结束线程之前，确保线程完成了必要的清理和资源释放工作。示例代码如下：

private volatile boolean isRunning = true;
    
    public void stopThread() {
        
        isRunning = false;
    }
    
    public void run() {
        
        while (isRunning) {
        
            // 线程执行的逻辑
        }
        // 清理操作
    }

*  **使用 interrupt() 方法**：调用线程的 `interrupt()` 方法可以中断线程的执行。线程可以通过检查 `Thread.interrupted()` 或 `Thread.isInterrupted()` 方法来响应中断请求，并做出适当的处理。示例代码如下：

public class MyThread extends Thread {
        
        @Override
        public void run() {
        
            while (!Thread.currentThread().isInterrupted()) {
        
                // 线程执行的代码
            }
    
            // 清理和资源释放逻辑
        }
    
        public void stopThread() {
        
            interrupt(); // 中断线程的执行（可选）
        }
    }

*  **使用 ExecutorService**：使用 ExecutorService 框架来管理线程的执行。通过调用 `shutdown()` 或 `shutdownNow()` 方法来安全地停止所有线程的执行。

（3）总之，直接调用 `stop()` 方法来结束线程是不安全的，可能会导致一些不可预知的问题。推荐使用以上安全的方式来结束线程，以确保线程可以正确退出并完成必要的清理工作。

[Java _Future]: https://xgqngu.blog.csdn.net/article/details/130169857
[Java]: https://xgqngu.blog.csdn.net/article/details/129976652