创建线程有几种不同的方式？你喜欢哪一种？为什么？

最新推荐文章于 2024-07-31 09:56:55 发布
最新推荐文章于 2024-07-31 09:56:55 发布
阅读量1.3k 收藏 5
点赞数 1
分类专栏： # Java面试题 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43999327/article/details/107255257
版权

java创建线程有四种方式：
（1）继承Thread类
（2）实现Runnable接口
（3）实现Callable接口、
（4）线程池

实现Runnable接口这种方式更受欢迎，因为这不需要继承Thread类。在应用设计中已经继承了别的对象的情况下，这需要多继承（而Java不支持多继承），只能实现接口。同时，线程池也是非常高效的，很容易实现和使用。

1、继承Thread类

import org.junit.Test;

//实现多线程的第一种方式
class MyThread extends Thread {
    private String name;

    public MyThread(String name) {
        this.name = name;
    }

    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            System.out.println(name + " is running......");
        }
    }

    public static void main(String[] args) {
        Thread a = new MyThread("线程A");
        Thread b = new MyThread("线程B");
        Thread c = new MyThread("线程C");
        a.start();
        b.start();
        c.start();
    }
}

输出：

线程A is running......
线程A is running......
线程A is running......
线程A is running......
线程A is running......
线程A is running......
线程A is running......
线程A is running......
线程A is running......
线程C is running......
线程C is running......
线程C is running......
线程C is running......
线程C is running......
线程C is running......
线程C is running......
线程C is running......
线程C is running......
线程C is running......
线程B is running......
线程B is running......
线程B is running......
线程B is running......
线程B is running......
线程B is running......
线程B is running......
线程B is running......
线程B is running......
线程B is running......
线程A is running......

本质上，Thread也实现了Runnable接口

class Thread implements Runnable {
	...
}

2、实现Runnable接口

import org.junit.Test;

//实现多线程的第二种方式
class MyRunnable implements Runnable {
    private String name;

    public MyRunnable(String name) {
        this.name = name;
    }

    @Override
    public void run() {
        for (int i = 0; i < 5; i++) {
            System.out.println(name + " is running......");
        }
    }

    public static void main(String[] args) {
        Thread one = new Thread(new MyRunnable("线程1"));
        Thread two = new Thread(new MyRunnable("线程2"));
        Thread three = new Thread(new MyRunnable("线程3"));
        one.start();
        two.start();
        three.start();
    }
}

输出：

线程3 is running......
线程3 is running......
线程3 is running......
线程3 is running......
线程3 is running......
线程2 is running......
线程1 is running......
线程2 is running......
线程2 is running......
线程2 is running......
线程2 is running......
线程1 is running......
线程1 is running......
线程1 is running......
线程1 is running......

3、实现Callable接口

import org.junit.Test;

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

//实现多线程的第三种方式
class MyCallable implements Callable<Integer> {

    private String name;
    private Integer number;

    public MyCallable(String name, Integer number) {
        this.name = name;
        this.number = number;
    }

    @Override
    public Integer call() throws Exception {
        for (int i = 0; i < number; i++) {
            System.out.println(name + " is running......");
        }
        return number;
    }

    public static void main(String[] args) throws ExecutionException, InterruptedException {
        //将Callable传入FutureTask
        FutureTask<Integer> ft1 = new FutureTask<Integer>(new MyCallable("线程一", 3));
        FutureTask<Integer> ft2 = new FutureTask<Integer>(new MyCallable("线程二", 4));
        FutureTask<Integer> ft3 = new FutureTask<Integer>(new MyCallable("线程三", 5));
        //将FutureTask传入Thread
        Thread t1 = new Thread(ft1);
        Thread t2 = new Thread(ft2);
        Thread t3 = new Thread(ft3);
        t1.start();
        t2.start();
        t3.start();
        //获取线程返回结果
        Integer number1 = ft1.get();
        Integer number2 = ft2.get();
        Integer number3 = ft3.get();
        System.out.println("线程一返回结果：" + number1);
        System.out.println("线程二返回结果：" + number2);
        System.out.println("线程三返回结果：" + number3);
    }
}

输出：

线程一 is running......
线程一 is running......
线程一 is running......
线程二 is running......
线程三 is running......
线程三 is running......
线程三 is running......
线程三 is running......
线程三 is running......
线程二 is running......
线程二 is running......
线程二 is running......
线程一返回结果：3
线程二返回结果：4
线程三返回结果：5

4、线程池

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

public class ThreadPool {
    public static void main(String[] args){

        //使用Executors工具类中的方法创建线程池
        ExecutorService pool = Executors.newFixedThreadPool(5);

        ThreadPoolDemo demo = new ThreadPoolDemo();

        //为线程池中的线程分配任务,使用submit方法，传入的参数可以是Runnable的实现类，也可以是Callable的实现类
        for(int i=1;i<=5;i++){
            pool.submit(demo);
        }

        //关闭线程池
        //shutdown ： 以一种平和的方式关闭线程池，在关闭线程池之前，会等待线程池中的所有的任务都结束，不在接受新任务
        //shutdownNow ： 立即关闭线程池
        pool.shutdown();


    }
}
class ThreadPoolDemo implements Runnable{

    /**多线程的共享数据*/
    private int i = 0;

    @Override
    public void run() {
        while(i<=50){
            System.out.println(Thread.currentThread().getName()+"---"+ i++);
        }
    }
}

输出：

pool-1-thread-1---0
pool-1-thread-5---4
pool-1-thread-5---6
pool-1-thread-1---5
pool-1-thread-4---3
pool-1-thread-4---9
pool-1-thread-4---10
pool-1-thread-3---1
pool-1-thread-3---12
pool-1-thread-2---2
pool-1-thread-3---13
pool-1-thread-3---15
pool-1-thread-3---16
pool-1-thread-3---17
pool-1-thread-3---18
pool-1-thread-3---19
pool-1-thread-3---20
pool-1-thread-3---21
pool-1-thread-3---22
pool-1-thread-4---11
pool-1-thread-4---24
pool-1-thread-4---25
pool-1-thread-4---26
pool-1-thread-4---27
pool-1-thread-4---28
pool-1-thread-4---29
pool-1-thread-4---30
pool-1-thread-4---31
pool-1-thread-4---32
pool-1-thread-4---33
pool-1-thread-4---34
pool-1-thread-4---35
pool-1-thread-4---36
pool-1-thread-4---37
pool-1-thread-4---38
pool-1-thread-1---8
pool-1-thread-1---40
pool-1-thread-5---7
pool-1-thread-5---42
pool-1-thread-5---43
pool-1-thread-5---44
pool-1-thread-5---45
pool-1-thread-5---46
pool-1-thread-5---47
pool-1-thread-5---48
pool-1-thread-5---49
pool-1-thread-5---50
pool-1-thread-1---41
pool-1-thread-4---39
pool-1-thread-3---23
pool-1-thread-2---14
二进制杯莫停
关注
  • 1
    点赞
  • 踩
  • 5
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
Android中线程（Thread）的创建及内存分配过程分析
卜大爷的博客
10-28 2万+
本文详细分析Android中，线程的创建过程以及线程创建时，内存的分配。
作为Java面试官，我会问Java程序员一些什么问题？，一线互联网大厂中高级Java面试真题收录
2401_84439743的博客
04-21 881
这份清华大牛整理的进大厂必备的redis视频、面试题和技术文档祝大家早日进入大厂，拿到满意的薪资和职级~~~加油！！！网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。需要这份系统化的资料的朋友，可以添加V获取：vip1024b （备注Java）一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！！
创建线程的方式有那些？
weixin_45623361的博客
11-04 956
4（1）写一个类继承Thread，覆盖重写run方法（2）创建一个Runnable类型的对象,实现run()方法,传入Thread的构造方法中（3）实现Callable接口，实现call()方法；（4）通过Executor的工具类创建线程池,通过线程池获取线程（一）继承java.lang包下的Thread类，覆盖重写thread类的run()方法,在run方法中实现运行在线程上的代码；
创建线程的四种方式
qq_62726340的博客
07-29 1231
2.创建Callable实现类的实例，并使用FutureTask类来包装Callable对象，该FutureTask对象封装了该Callable对象的call()方法的返回值；3.调用其对象的start()方法，该方法表示启动一个线程，线程处于就绪状态，如果获取到cpu执行权，则会调用run()方法，执行对应的任务；3.将此对象作为形参传递到Thread类的构造器中，创建Thread类的对象，调用start()方法，启动线程；4.调用FutureTask对象的get()方法来获取子线程执行结束后的返回值；
创建线程几种方式
刘涛的博客
04-12 3781
创建线程的几种方式： 方式1：通过继承Thread类创建线程 步骤：1.定义Thread类的子类，并重写该类的run方法，该方法的方法体就是线程需要执行的任务，因此run()方法也被称为线程执行体 2.创建Thread子类的实例，也就是创建了线程对象 3.启动线程，即调用线程的start()方法 方式2：通过实现Runnable接口创建线程 步骤：1.定义Runnable接口的实现类，一样要重写...
线程创建的方式具体有哪几种？
scmagic的博客
11-18 477
关于这个问题有很多种说法，我觉得都不对，下面我说下自己的看法 线程创建的方式具体有哪几种？ 这要从不同的角度来看，从Oracle官方的描述，通常我们可以分为两类，也就是thread和runnable，但是准确的来讲，创建线程只有一种方式，那就是构造thread类，而实现线程执行单元有两种方式： 一种是实现runnable接口的run方法，并把runnable实例传给Thread类，一种是重写Thread的run方法（我们可以通过线程池来创建，但是线程池的本质也是在threadfactory里面new了一个t
线程创建的三种方式
解决bug的路上
09-01 3626
第一种，通过继承Thread类创建线程类 1、定义一个类继承Thread类，并重写Thread类的run()方法，run()方法的方法体就是线程要完成的任务，因此把run()称为线程的执行体； 2、创建该类的实例对象，即创建了线程对象； 3、调用线程对象的start()方法来启动线程； 第二种，通过实现Runnable接口创建线程类 1、定义一个类实现Runnable接口； 2、创建该类的实例对象obj； 3、将obj作为构造器参数传入Thread类实例对象，这个对象才是真正的线程对象； 4、调用线程对象的
如何区分进程、线程和协程？看这篇就够了！
最新发布
孤芳不自赏
07-31 534
嗨，大家好！我是小米，今天我们来聊聊操作系统中的三大执行单元：进程、线程和协程。你知道它们有什么区别吗？为什么说进程独立性强，线程高效，协程更适合I/O密集型任务？本文将带你深入探讨这些概念，帮助你在实际开发中灵活运用，提升性能！准备好了吗？一起开始吧！
C语言既有高级语言又有低级语言的特点，但为什么它不是低级语言呢？
Hsuesh的博客
11-07 1807
在相继出现 Meltdown 和 Spectre 漏洞之后，花一些时间研究造成漏洞的根本原因是值得的。这两个漏洞都涉及处理器绕过某种访问检查直接执行指令，让攻击者可以通过侧通道观察执行结果。导致这些漏洞的原因让 C 语言程序员相信他们正在使用的是一门低级的编程语言，但几十年来，情况并非如此。 不仅仅是处理器厂商，这件事情与我们这些从事 C/C++ 编译器研究的人也不无关系。 什么是低级编程语言？ 计算机科学先驱 Alan Perlis 对低级编程语言的定义： “当一门编程语言的程序要求把注.
作为Java面试官，我会问Java程序员一些什么问题？
m0_63174618的博客
11-01 888
我在面试的时候，生怕漏了明珠，所以总会问来面试的同学： 你擅长什么？ Java、数据库、前端你哪方面掌握的比较好？ 你常用的技术栈是什么？ 说一件让你印象深刻的事，可以展现你解决问题的能力，或者学习的能力。 好了，以上就是我的面试套路。你掌握了这个套路，是不是就能套路我了？ 所以，你到底有没有某一方面可以打动面试官的点呢？ 在面试时，我会在上面那些套路的问题时，追着去问你所掌握的技术栈能力。 譬如你说你擅长后端，我就会问些Java、中间件； 你说擅长数据库，我会临时出个题，让你写个SQL； 你说
线程创建的几种方式
sofia_fhx的博客
03-22 276
一、什么是自动装箱拆箱 装箱就是自动将基本数据类型转换为包装器类型；拆箱就是自动将包装器类型转换为基本数据类型。 1 //自动装箱 2 Integer total = 99; 3 4 //自定拆箱 5 int totalprim = total; 下面我们来看看需要装箱拆箱的类型有哪些： 这个过程是自动执行的，那么我们需要看看它的执行过程： 1 publ...
创建线程有几种不同的方式？
wang_xing1993的博客
04-20 7709
①继承Thread类（真正意义上的线程类），是Runnable接口的实现。 ②实现Runnable接口，并重写里面的run方法。 ③使用Executor框架创建线程池。Executor框架是juc里提供的线程池的实现。 调用线程的start()：启动此线程；调用相应的run()方法 继承于Thread类的线程类，可以直接调用start方法启动线程（使用static也可以实现资源共享）.一个
创建线程有几种方式
LiJianGuo_Mr的博客
09-09 162
创建线程有几种方式 **1) 继承thread类：**本质是是实现了runnable接口的一个实例，代表一个线程的实例。启动线程的唯一方法就是通过tead类的start（）死大特start()是一个native内体武方法它将启动一个新线程，执行run（） **2) 实现runnable接口：**如果自己的类已经extends 另一个类，就无法直接extends Thread，此时，可以实现一个Runnable 接口。 3) 实现卡了波callable接口：Callabled 接口有点像是Runnabl
线程的创建方式有哪些
qq_46138725的博客
06-12 141
1.继承Thread类实现 2.实现Ruunable接口方式 3.实现Callable接口方式 4.其中前两种比较常用，但是，需要有返回值需要实现Callable借口 辅助理解 继承Thread类实现 public class MyThread extends Thread{ @Override public void run(){ super.run(); System.out.println("hello") } } 调用 MyThread thread = new MyThread（）
创建线程有哪几种方式？
09-11
### 回答1： 在 Python 中创建线程有以下几种方式: 1. 使用 `threading` 模块: 使用这种方式需要创建一个 `Thread` 类的实例, 然后调用它的 `start()` 方法来启动新线程。 2. 使用 `_thread` 模块: 这种方式与使用 `threading` 模块类似, 也需要调用 `start_new_thread()` 函数来启动新线程。 3. 使用多进程: Python 中的 `multiprocessing` 模块可以轻松地创建新的进程。 4. 使用其他第三方库: 例如 `gevent` 和 `concurrent.futures` 等库也可以用来创建线程。 ### 回答2： 在Java中，创建线程有以下几种方式： 1. 继承Thread类：继承Thread类并重写其run方法，然后实例化该类的对象，调用start方法启动线程。示例代码如下： ``` public class MyThread extends Thread { @Override public void run() { // 线程要执行的代码 } } // 创建并启动线程 MyThread thread = new MyThread(); thread.start(); ``` 2. 实现Runnable接口：实现Runnable接口，并实现其run方法，然后创建Thread对象并将Runnable实例作为参数传递给Thread对象，最后调用start方法启动线程。示例代码如下： ``` public class MyRunnable implements Runnable { @Override public void run() { // 线程要执行的代码 } } // 创建并启动线程 MyRunnable runnable = new MyRunnable(); Thread thread = new Thread(runnable); thread.start(); ``` 3. 使用Callable和Future：使用Callable接口代替Runnable接口，重写call方法，然后创建ExecutorService对象，通过submit方法提交Callable对象，最后得到Future对象并通过get方法获取结果。示例代码如下： ``` public class MyCallable implements Callable<Integer> { @Override public Integer call() throws Exception { // 线程要执行的代码 return result; } } // 创建线程池并提交Callable对象 ExecutorService executor = Executors.newFixedThreadPool(1); MyCallable callable = new MyCallable(); Future<Integer> future = executor.submit(callable); // 获取线程结果 Integer result = future.get(); // 关闭线程池 executor.shutdown(); ``` 通过以上几种方式，可以灵活地创建和启动线程，并执行相应的任务。 ### 回答3： 创建线程的方式有以下几种： 1. 使用继承Thread类：创建一个新的类，继承自Thread类，并重写run()方法，在run()方法中定义线程要执行的任务。然后实例化这个新类的对象，并调用对象的start()方法来启动线程。 2. 实现Runnable接口：创建一个新的类，实现Runnable接口，并实现其中的run()方法。然后实例化这个新类的对象，并将对象作为参数传递给Thread类的构造方法创建Thread对象。最后调用Thread对象的start()方法启动线程。 3. 使用Callable和Future接口：创建一个新的类，实现Callable接口，并实现其中的call()方法。然后利用ExecutorService线程池的submit()方法提交Callable对象，得到一个Future对象，通过Future对象的get()方法获取线程的返回值。 4. 使用线程池：通过ExecutorService线程池来管理线程的创建和执行。可以使用ThreadPoolExecutor类来自定义线程池的大小和其他相关参数。 这些方式可以根据实际需求选择不同的方法来创建线程。使用继承Thread类或实现Runnable接口比较简单，适合简单的线程任务。使用Callable和Future接口可以获取线程的返回值。使用线程池可以有效管理线程的创建和执行，提高系统资源的利用率。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值