面试八股之线程篇1.3——基础——创建线程的四种方式及区别

Ethan Yankang

已于 2024-07-28 16:04:26 修改

阅读量965

点赞数 10

分类专栏：面试 # 线程文章标签：面试职场和发展

于 2024-05-30 10:57:19 首次发布

本文链接：https://blog.csdn.net/m0_68657832/article/details/139318187

版权

面试同时被 2 个专栏收录

219 篇文章 13 订阅

订阅专栏

线程

54 篇文章 0 订阅

订阅专栏

🌈hello，你好鸭，我是Ethan，西安电子科技大学大三在读，很高兴你能来阅读。

✔️目前博客主要更新Java系列、项目案例、计算机必学四件套等。
🏃人生之义，在于追求，不在成败，勤通大道。加油呀！

🔥个人主页：Ethan Yankang
🔥推荐：史上最强八股文||一分钟看完我的几百篇博客

🔥温馨提示：划到文末发现专栏彩蛋点击这里直接传送

🔥本篇概览：详细讲解了创建线程的四种方式及区别。一个鸡翅，两个实现。🌈⭕🔥

【计算机领域一切迷惑的源头都是基本概念的模糊，算法除外】

🌈序言：

JAVA八股文就是最最基础之事，此关不过，啥都没有。今日得《黑马程序员之八股》良品辅助，代码随想录之优品引导，《JAVA核心技术》之极品传教，应按此三者学之习之，时时复习，长此以往必能穿魂入脉，习得大功。

应该四处查阅浏览八股技术博客之，不应固守一隅，应集百家之所长而习得内功。

对于一个强烈想完全掌握JAVA的技术宅来说，JAVA的XXX万万不能放过，这些基础的概念例程都值得细细体味的，千万别觉得都是文字，浪费时间，记住——别违背科学发展的客观规律。别一味地赶进度以满足自己学的都么快的虚荣心，自欺欺人，要老老实实的走好每一步。

每一次复习八股文都是复习JAVA基础的绝佳机会，切借此机会融会贯通之。

🔥 史上最全JAVA八股文，欢迎收藏 -CSDN博客

🔥 所有JAVA基础一键查阅（含习题集）-CSDN博客

1.3 创建线程的四种方式

难易程度：☆☆

出现频率：☆☆☆☆

参考回答：

共有四种方式可以创建线程，分别是：

继承Thread类、实现runnable接口、实现Callable接口、线程池创建线程

详细创建方式参考下面代码：

① 继承Thread类

public class MyThread extends Thread {

    @Override
    public void run() {
        System.out.println("MyThread...run...");
    }
    
    public static void main(String[] args) {
        // 创建MyThread对象
        MyThread t1 = new MyThread() ;
        MyThread t2 = new MyThread() ;
        // 调用start方法启动线程
        t1.start();
        t2.start();

    }
    
}

②实现runnable接口

public class MyRunnable implements Runnable {
    @Override
    public void run() {
        // 线程执行的具体逻辑
        System.out.println("这是通过实现 Runnable 接口创建的线程");
    }

    public static void main(String[] args) {

        MyRunnable runnable = new MyRunnable();
        Thread thread = new Thread(runnable);
        thread.start();
    }
}

②①🔥实现runnable接口——>lamabd最优美

一条语句就可以执行！！

public class RunnableLambdaExample {
    public static void main(String[] args) {
        // 使用 Lambda 表达式实现 Runnable 接口
        new Thread(() -> {
            System.out.println("这是通过实现 Runnable 接口创建的线程（使用 Lambda 表达式）");
        }).start();
    }
}

③ 实现Callable接口

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;

public class MyCallable implements Callable<String> {

    @Override
    public String call() throws Exception {
        // 线程执行的具体逻辑，并返回结果
        return "这是通过实现 Callable 接口创建的线程，并返回了结果";
    }

    public static void main(String[] args) throws InterruptedException, ExecutionException {
        MyCallable callable = new MyCallable();
        FutureTask<String> futureTask = new FutureTask<>(callable);
        new Thread(futureTask).start();
        String result = futureTask.get();
        System.out.println(result);
    }
}

③①🔥实现callable接口——>lamabd最优美

import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;

public class CallableLambdaExample {
    public static void main(String[] args) throws InterruptedException, ExecutionException {
        // 使用 Lambda 表达式实现 Callable 接口
        FutureTask<String> futureTask = new FutureTask<>(() -> {
            return "这是通过实现 Callable 接口创建的线程，并返回了结果（使用 Lambda 表达式）";}
);
        new Thread(futureTask).start();
        String result = futureTask.get();
        System.out.println(result);
    }
}

④ 线程池创建线程

package com.itheima;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

/**
 * @Author: Ethan Yankang
 * @Program: interview
 * @Date: 2024-07-28 15:44
 **/
public class ThreadByThreadPool {
    public static void main(String[] args) {
        // 创建一个固定大小为 5 的线程池
        ExecutorService executor = Executors.newFixedThreadPool(5);
        // 提交 10 个任务到线程池
        for (int i = 0; i < 10; i++) {
            executor.execute(new Task(i));
        }
        // 关闭线程池
        executor.shutdown();
    }

//    创建内部类
    static class Task implements Runnable {
        private int taskId;

        public Task(int taskId) {
            this.taskId = taskId;
        }

        @Override
        public void run() {
            System.out.println("Task " + taskId + " is running");
            try {
                // 模拟任务执行时间
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("Task " + taskId + " is completed");
        }
    }
}

在这个示例中，提交的任务数量（10个）确实大于线程池的大小（5个）。这是线程池设计中的一个常见情况。线程池会管理这些任务的执行，通过队列机制来处理任务数量与线程池大小之间的差异。以下是详细解释：

线程池如何处理任务队列

任务队列：
- 当线程池中的所有线程都在忙于执行任务时，线程池会将新提交的任务放入一个内部的任务队列中。任务队列通常是一个阻塞队列（如 LinkedBlockingQueue），它能保存等待执行的任务。
任务执行：
- 线程池中的线程一旦完成当前任务，会从任务队列中取出下一个任务并执行。
- 如果队列中没有任务，线程会进入等待状态，直到有新的任务提交到队列中。

预期输出

输出的顺序可能会有所不同，因为任务是并发执行的，但可以预期输出类似以下内容：

Task 0 is running
Task 1 is running
Task 2 is running
Task 3 is running
Task 4 is running
Task 0 is completed
Task 5 is running
Task 1 is completed
Task 6 is running
Task 2 is completed
Task 7 is running
Task 3 is completed
Task 8 is running
Task 4 is completed
Task 9 is running
Task 5 is completed
Task 6 is completed
Task 7 is completed
Task 8 is completed
Task 9 is completed