大家都说Java有三种创建线程的方式！并发编程中的惊天骗局！-六虎

导言

今日来聊一个比较有意思的话题，这是一道Java陈腔滥调文中的陈腔滥调文，简称陈腔滥调文Plus！

这个疑问在很久之前便在我心中产生了，久远到什么程度呢？大约能够从盘古开天地开端算起，哈哈哈。

先来看看本次的主角，便是一个问题：“Java中有几种创立线程的办法？”

我们能够先试着答复一下，答复完之后再往下看。

PS：个人编写的《技能人求职指南》小册已结束，其间从技能总结开端，到制定期望、技能突击、简历优化、面试预备、面试技巧、谈薪技巧、面试复盘、选Offer办法、新人入职、进阶提升、职业规划、技能管理、涨薪跳槽、裁定补偿、副业兼职……，为我们打造了一套“从求职到跳槽”的一条龙服务，一起也为诸位预备了七折优惠码：3DoleNaE，感兴趣的小伙伴能够点击：s./ds/USoa2R3/了解概况！

一、浅谈Java线程的创立办法

回到前面的那个问题，假如是个一般Java程序员，应该会答复“三种”，分别为：

①承继Thread类；
②完成Runnable接口；
③完成Callable接口。

假如是Pro版的Java程序员，应该会答复“四种”，分别为：

①承继Thread类；
②完成Runnable接口；
③完成Callable接口；
④运用ExecutorService线程池。

假如是Plus版的Java程序员，应该会答复“五种”，分别为：

①承继Thread类；
②完成Runnable接口；
③完成Callable接口；
④运用ExecutorService线程池；
⑤运用CompletableFuture类。

假如是ProMax版的Java程序员，应该会答复“七种”，分别为：

①承继Thread类；
②完成Runnable接口；
③完成Callable接口；
④运用ExecutorService线程池；
⑤运用CompletableFuture类；
⑥根据ThreadGroup线程组；
⑦运用FutureTask类。

假如是超级至尊版的Java程序员，或许还会答复“十种”，分别为：

①承继Thread类；
②完成Runnable接口；
③完成Callable接口；
④运用ExecutorService线程池；
⑤运用CompletableFuture类；
⑥根据ThreadGroup线程组；
⑦运用FutureTask类；
⑧运用匿名内部类或Lambda表达式；
⑨运用Timer定时器类；
⑩运用ForkJoin线程池或Stream并行流。

假如是……版的Java程序员，或许还会整出十二种、十三种……，但我就不持续往下罗列了，先简单将上述提到的十种办法，编写出相应的代码。

1.1、承继Thread类

这是最一般的办法，承继Thread类，重写run办法，如下：

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

1.2、完成Runnable接口

这也是一种常见的办法，完成Runnable接口偏重写run办法，如下：

public class ImplementsRunnable implements Runnable {
    @Override
    public void run() {
        System.out.println("2......");
    }
    public static void main(String[] args) {
        ImplementsRunnable runnable = new ImplementsRunnable();
        new Thread(runnable).start();
    }
}

想深入研讨能够参阅之前《Runnable剖析》的文章。

1.3、完成Callable接口

和上一种办法相似，只不过这种办法能够拿到线程履行完的返回值，如下：

public class ImplementsCallable implements Callable<String> {
    @Override
    public String call() throws Exception {
        System.out.println("3......");
        return "zhuZi";
    }
    public static void main(String[] args) throws Exception {
        ImplementsCallable callable = new ImplementsCallable();
        FutureTask<String> futureTask = new FutureTask<>(callable);
        new Thread(futureTask).start();
        System.out.println(futureTask.get());
    }
}

想深入研讨能够参阅之前《Callable剖析》的文章。

1.4、运用ExecutorService线程池

这种归于进阶办法，能够经过Executors创立线程池，也能够自界说线程池，如下：

public class UseExecutorService {
    public static void main(String[] args) {
        ExecutorService poolA = Executors.newFixedThreadPool(2);
        poolA.execute(()->{
            System.out.println("4A......");
        });
        poolA.shutdown();
        // 又或许自界说线程池
        ThreadPoolExecutor poolB = new ThreadPoolExecutor(2, 3, 0,
                TimeUnit.SECONDS, new LinkedBlockingQueue<Runnable>(3),
                Executors.defaultThreadFactory(), new ThreadPoolExecutor.AbortPolicy());
        poolB.submit(()->{
            System.out.println("4B......");
        });
        poolB.shutdown();
    }
}

详细能够参阅之前《剖析ThreadPoolExecutor线程池》的文章。

1.5、运用CompletableFuture类

CompletableFuture是JDK1.8引进的新类，能够用来履行异步使命，如下：

public class UseCompletableFuture {
    public static void main(String[] args) throws InterruptedException {
        CompletableFuture<String> cf = CompletableFuture.supplyAsync(() -> {
            System.out.println("5......");
            return "zhuZi";
        });
        // 需求阻塞，不然看不到成果
        Thread.sleep(1000);
    }
}

详细能够参阅之前《详解CompletableFuture》的文章。

1.6、根据ThreadGroup线程组

Java线程能够分组，能够创立多条线程作为一个组，如下：

public class UseThreadGroup {
    public static void main(String[] args) {
        ThreadGroup group = new ThreadGroup("groupName");
        new Thread(group, ()->{
            System.out.println("6-T1......");
        }, "T1").start();
        new Thread(group, ()->{
            System.out.println("6-T2......");
        }, "T2").start();
        new Thread(group, ()->{
            System.out.println("6-T3......");
        }, "T3").start();
    }
}

1.7、运用FutureTask类

这个和之前完成Callable接口的办法差不多，只不过用匿名形式创立Callable，如下：

public class UseFutureTask {
    public static void main(String[] args) {
        FutureTask<String> futureTask = new FutureTask<>(() -> {
            System.out.println("7......");
            return "zhuZi";
        });
        new Thread(futureTask).start();
    }
}

想深入研讨能够参阅之前《剖析FutureTask类》的文章。

1.8、运用匿名内部类或Lambda

这种办法归于硬扯，便是直接new前面所说的Runnable接口，或许经过Lambda表达式书写，如下：

public class UseAnonymousClass {
    public static void main(String[] args) {
        new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("8A......");
            }
        }).start();
        new Thread(() -> 
                System.out.println("8B......")
        ).start();
    }
}

1.9、运用Timer定时器类

在JDK1.3时，曾引进了一个Timer类，用来履行定时使命，如下：

public class UseTimer {
    public static void main(String[] args) {
        Timer timer = new Timer();
        timer.schedule(new TimerTask() {
            @Override
            public void run() {
                System.out.println("9......");
            }
        }, 0, 1000);
    }
}

里面需求传入两个数字，第一个代表启动后多久开端履行，第二个代表每间隔多久履行一次，单位是ms毫秒。

1.10、运用ForkJoin或Stream并行流

ForkJoin是JDK1.7引进的新线程池，根据分治思想完成。而后续JDK1.8的parallelStream并行流，默许就根据ForkJoin完成，如下：

public class UseForkJoinPool {
    public static void main(String[] args) {
        ForkJoinPool forkJoinPool = new ForkJoinPool();
        forkJoinPool.execute(()->{
            System.out.println("10A......");
        });
        List<String> list = Arrays.asList("10B......");
        list.parallelStream().forEach(System.out::println);
    }
}

想要深入研讨能够参阅《全解ForkJoinPool》的上下两篇文章。

二、陈腔滥调文中的惊天圈套

看完前面第一阶段，是不是说的头头是道？假如你也这样认为，恭喜你被带偏了！

不知道从何时起，Java并发编程的陈腔滥调文，在“Java有几种创立线程的办法”这道题上，开端以“数量”为荣，写的越多，显得越专业，越牛X，我们去百度搜个关键词：

“Java有几种办法创立线程？”

呈现的答案，最少都有四种，那这真的对吗？能够说对，但严格意义上来说，又不对。

抛开后边一些先不谈，咱们就聊最开端的三种：“承继Thread类、完成Runnable接口、完成Callable接口”，这应该是广为人知的答案，不管是刚入行的小白，还是在业界深耕已久的老鸟，信任都背过这一道陈腔滥调文。

那么此时来看个例子：

public class ImplementsRunnable implements Runnable {
    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName()
                + "：竹子爱熊猫");
    }
}

这儿界说了一个类，完成了Runnable接口偏重写了run办法，按前面的说法，这种办法是不是创立了一条线程？答案是Yes，可问题来了，请你告诉我，该如何启动这条所谓的“线程”呢？

public static void main(String[] args) {
    ImplementsRunnable runnable = new ImplementsRunnable();
    runnable.run();
}

难道像上面这样嘛？来看看运转成果：

main：竹子爱熊猫

成果很显然，打印出的线程姓名为：main，代表现在是主线程在运转，和调用一般办法没任何区别，那究竟该如何创立一条线程呀？要这样做：

public static void main(String[] args) {
    ImplementsRunnable runnable = new ImplementsRunnable();
    new Thread(runnable).start();
}

先new出Runnable目标，接着再new一个Thread目标，然后把Runnable丢给Thread，接着调用start()办法，此时才干真实意义上创立一条线程，运转成果如下：

Thread-0：竹子爱熊猫

此时线程姓名变成了Thread-0，这意味着输出“竹子爱熊猫”这句话的代码，并不是main线程在履行了，所以聊到这儿，我们理解我想表达的意义了嘛？完成了Runnable接口的ImplementsRunnable类，并不能被称为一条线程，包含所谓的Callable、FutureTask……，都不能创立出真实的线程。

换到前面所提出的三种办法中，只要承继Thread类，才干真实创立一条线程，如下：

public class ExtendsThread extends Thread {
    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName()
                + "：竹子爱熊猫");
    }
    public static void main(String[] args) {
        new ExtendsThread().start();
    }
}
// 运转成果：
//      Thread-0：竹子爱熊猫

由于当你用一个类，承继Thread类时，它内部所有的办法，都会被承继过来，所以当时类能够直接调用start()办法启动，更详细点来说，在Java中，创立线程的办法就只要一种：调用Thread.start()办法！只要这种形式，才干在真实意义上创立一条线程！

而例如ExecutorService线程池、ForkJoin线程池、CompletableFuture类、Timer定时器类、parallelStream并行流……，假如有去看过它们源码的小伙伴应该清楚，它们终究都依赖于Thread.start()办法创立线程。

好了，搞清楚这点之后，再回头来看Runnable、Callable，这俩已然不是创立线程的办法，那它们究竟是什么？这点咱们放到后边去讨论，先来聊聊“Java有三种创立线程的办法”，这个以讹传讹的陈腔滥调文，到底是怎样来的呢？

究根结底，这个错误观念的源头，来自于《Java编程思想》（《Thinking In Java》）和《Java核心技能》（《Core Java》）这两本书。在《Core Java》这本书的第12、13章，专门对多线程编程进行了解说，提到了四种创立线程的办法：

①承继Thread类，偏重写run()办法；
②完成Runnable接口，并传递给Thread结构器；
③完成Callable接口，创立有返回值的线程；
④运用Executor框架创立线程池。

相同的内容，在《Thinking In Java》的第二十一章，也有重复提及到。于是，国内阅读过这两本书本的人，在写文章、写面试题、写书本、授课、录视频……时，把这个概念越传越泛，按照“三人成虎”准则，Java有3、4种创立线程的办法，这个观念变成了事实，从此刻在了每个Java开发者的DNA里。

好了，搞清楚问题的缘由，咱们回到前面提出的问题，已然完成Runnable、Callable接口，不是创立线程的办法，那它们究竟是什么？准确来说，这是两种创立“线程体”的办法，包含承继Thread类重写run()办法也是。

三、线程与线程体的联系

前面或许提出了一个我们没触摸过的新概念：线程体，这是个啥？来看看ChatGPT的解说：

看完这个答复，信任我们就能理解“线程体”是怎样一回事了，说简单点，线程是一个独立的履行单元，能够被操作系统调度；而线程体仅仅只是一个使命，就相似于一段一般的代码，需求线程作为载体才干运转，ChatGPT给出的总结特别对：线程是履行线程体的容器，线程体是一个可运转的使命。

不过Java中创立线程体的办法，能够根据Runnable创立，也能够靠Callable创立带返回的、也能够经过Timer创立支撑定时的……，但不管是哪种办法，到最后都是依赖于Runnable这个类完成的，假如我们有去研讨过Callable的原理，我们就会发现：Callable实际上便是Runnable的封装体。

到这儿，搞清线程与线程体的联系后，信任我们就必定理解了我为何说：Java中创立线程只要Thread.start()这一种办法的原因了！而最开端给出的其他办法，要么是在封装Thread.start()，要么是在创立线程体，而这个所谓的线程体，更接地气的说，应该是“多线程使命”。

new Runnable(...);
new Callable(...);

这并不是在创立线程，而是创立了两个能够提供给线程履行的“多线程使命”。

不过还有个问题，使命和线程，到底是怎样产生绑定联系的呢？我们能够去看Thread类提供的结构器，应该会发现这个结构函数：

public Thread(Runnable target) {
    init(null, target, "Thread-" + nextThreadNum(), 0);
}

当new``Thread目标并传入一个使命时，内部会调用init()办法，把传入的使命target传进去，一起还会给线程起个默许姓名，即Thread-x，这个x会从0开端（线程姓名也能够自界说）。

而当我们去测验持续跟进init()办法时，会发现它在做一系列预备工作，如安全检测、设定名称、绑定线程组、设置守护线程……，当init()办法履行完成后，就能够调用Thread.start()办法启动线程啦。

启动线程时，终究会调用到start0()这个JNI办法，转而会去调用JVM的本地办法，即C/C++所编写的办法，源码我就不带着我们去跟了，感兴趣的能够去down一下OpenJDK的源码，或许去搜一下Thread.start()的完成原理，我这儿就大致总结一下大体过程。

①Thread在类加载阶段，就会经过静态代码块去绑定Thread类办法与JVM本地办法的联系：

private static native void registerNatives();
static {
    registerNatives();
}

履行完这个registerNatives()本地办法后，Java的线程办法，就和JVM办法绑定了，如start0()这个办法，会对应着JVM_StartThread()这个C++函数等（详细代码坐落openjdk\jdk\src\share\native\java\lang\Thread.c这个文件）。

②当调用Thread.start()办法后，会先调用Java中界说的start0()，接着会找到与之绑定的JVM_StartThread()这个JVM函数履行（详细完成坐落openjdk\hotspot\src\share\vm\prims\jvm.cpp这个文件）。

③JVM_StartThread()函数终究会调用os::create_thread(...)这个函数，这个函数依旧是JVM函数，毕竟Java要完成跨平台特性，而不同操作系统创立线程的内核函数，也有所差异，如Linux操作系统中，创立线程终究会调用到pthread_create(...)这个内核函数。

④创立出一条内核线程后，接着会去履行Thread::start(...)函数，接着会去履行os::start_thread(thread)这个函数，这一步的作用，主要是让Java线程，和内核线程产生映射联系，也会在这一步，把Runnable线程体，顺势传递给OS的内核线程（详细完成坐落openjdk\hotspot\src\share\vm\runtime\Thread.cpp这个文件）。

⑤当Java线程与内核线程产生映射后，接着就会履行载入的线程体（线程使命），也便是Java程序员所编写的那个run()办法。

四、总结

看到这儿，这篇文章也就结束了，相较于以往的文章，篇幅方面略显短小，本文重在纠正我们的错误观念，叙述一种学习思想：看任何东西请保持质疑，不要无条件信任他人的说法，要锻炼自己的深度思考能力，而不是听风便是雨！学习时请记住这个准则，这才干让你真实发生质的生长。

最后，假如今后你的面试中，被问到“Java有几种创立线程的办法”这个问题时，也期望按照本文所说，在面试中聊出与他人不一样的观点，例如：

Java创立线程有很多种办法啊，像完成Runnable、Callable接口、承继Thread类、创立线程池等等，不过这些办法并没有真实创立出线程，严格来说，Java就只要一种办法能够创立线程，那便是经过new Thread().start()创立。
而所谓的Runnable、Callable……目标，这仅仅只是线程体，也便是提供给线程履行的使命，并不归于真实的Java线程，它们的履行，终究还是需求依赖于new Thread()……

我们换位思考一下，面试官问他人时，答案都是千篇一律的那三种、四种、五种……，而你能聊出这样的观点，是不是特别能让他眼前一亮？因此面试的差异化就来了，他人都是陈腔滥调文选手，而你拥有着自己的理解，这自然能让对方给你打上更高的评分，和他人竞赛Offer时，那不便是手到拈来嘛~

最后的最后，假如看完本文对你有所启示，记得点赞、关注、收藏支撑一下，假如平时想更方便看技能文章的小伙伴，也欢迎关注我的同名公众号：竹子爱熊猫。

大家都说Java有三种创建线程的方式！并发编程中的惊天骗局！

导言

一、浅谈Java线程的创立办法

1.1、承继Thread类

1.2、完成Runnable接口

1.3、完成Callable接口

1.4、运用ExecutorService线程池

1.5、运用CompletableFuture类

1.6、根据ThreadGroup线程组

1.7、运用FutureTask类

1.8、运用匿名内部类或Lambda

1.9、运用Timer定时器类

1.10、运用ForkJoin或Stream并行流

二、陈腔滥调文中的惊天圈套

三、线程与线程体的联系

四、总结

作者信息

推广

大家都说Java有三种创建线程的方式！并发编程中的惊天骗局！

导言

一、浅谈Java线程的创立办法

1.1、承继Thread类

1.2、完成Runnable接口

1.3、完成Callable接口

1.4、运用ExecutorService线程池

1.5、运用CompletableFuture类

1.6、根据ThreadGroup线程组

1.7、运用FutureTask类

1.8、运用匿名内部类或Lambda

1.9、运用Timer定时器类

1.10、运用ForkJoin或Stream并行流

二、陈腔滥调文中的惊天圈套

三、线程与线程体的联系

四、总结

相关文章

数据工厂系列（10）用户模块功能开发

详解Python中sys模块的功能与应用

深入理解ConcurrentHashMap的原理和实现

基于TCP协议的Socket通信

作者信息

推广