线程组多次调用_创建线程的两个方法（官网说两种，我们就别说什么三种四种了）...

落日映苍穹つ 2023-01-07 03:58 8阅读 0赞

# 一.有多少种实现多线程的方法？ #

**1**.不同的角度有不同的答案

**2**.典型的答案有两种，分别是实现Runnable接口和继承Thread类

**3**.但是看原理，其实Thread类实现了Runnable接口，并且看Thread类的run方法，会发现其两者本质是一样的，run方法发代码如下：

@OverridePublic void run(){    if(target != null){        target.run();    }}

方法1和方法2，也就是说“实现Runnable类”和“继承Thread类然后重写run()”在实现多线程本质上，并没有区别，都最终调用了start()方法来新建线程，这两种方法主要区别在于run()方法来源：方法1:最终调用target.run();

方法2:run()整个都被重写

**4**.还有其他的实现线程的方法，例如线程池定时器等，他们也能新建线程，但是看源码，从没有逃出本质，也就是实现Runnable接口和继承Thread类。

**5**.所以总结来说，我们只能通过新建Thread类这一种方式来创建线程，但是类里面的run方法有两种方式来实现，第一种是重写run方法，第二种实现Runnable接口的run方法，然后再把该runnable实例传递给Thread类。除此之外，从表象上看线程池，定时器等工具类也可以创建线程，但是它们的本质都逃不过上面的范围。

# 二.为什么实现Runnable接口比继承Thread更好？ #

**1**.相比较，实现Runnable接口更好，一般都会优先考虑这种发放，除非迫不得已，我们是不考虑继承Thread类的。原因有三点第一点：从代码架构考虑，具体执行的任务，即run方法，它应该和线程创建运行也就是Thread类是接偶的，不应该将两者混为一谈，所以从接偶角度来看，实现Runnable更好。

第二点：如果继承Thread类，每次新建一个任务，只能为此新建一个独立的线程，而新建一个独立的线程的损耗是非常大的，它需要创建然后执行，执行完后需要销毁，而使用Runnable就可以使用线程池之类的工具，就可以大大减小创建销毁线程带来的损耗。

第三点：继承了Thread类后，由于java不支持双继承，不能再继承其他的类，限制了代码的可扩展性。

**线程池创建线程：**

public class ThreadPool{    public static void main(String[] args){        ExecutorService executorService = Executors.newCachedThreadPool();        for(int i=0; I<100;i++){            executorService.submit(new Task(){        });        }    }}Class Task implements Runnable{    @Override    public void run(){        try{        Thread.sleep(500);        }catch(InterruptedException e){            e.printStackTrace();        }    System.out.println(Thread.currentThread().getName());    }}

**定时器创建线程：**

public class DemoTimerTask{    public static void main(String[] args){        Timer timer = new timer();        timer.scheduleAtFixedRate(new TimerTask(){            @Override            public void run(){      System.out.println(Thread.currentThread().getName());            }        },1000,1000);    }}

**匿名内部类实现线程：**

public static void main(String[] args){    new Thread(){        @Override        public void run (){    System.out.println(Thread.currentThread().getName());        }    }.start();    new Thread(new Runnable(){        @Override        public void run (){    System.out.println(Thread.currentThread().getName());        }    }).start(); }

**Lambda表达式实现线程：**

public static void main(String[] args){    new Thread(() ->    System.out.println(Thread.currentThread().getName())).start(    );}

**如果一个线程两次调用start方法会怎样？为什么？**

会抛出一个异常(IllegalThreadStateException),因为在start方法第一行，就会误检查线程的状态，如果不是0，即不是初始状态，就会抛出异常，因为线程状态是不可逆的，所以已经执行过start后，状态改变了，就不能再执行start方法了。

![32e080eb8d94295b970ee4fa1b8ec2a4.png][]

在这里插入图片描述

**start()既然也是调用的run()方法，为什么不直接调用run()而是调用start()?**

因为调用start()才是真正的去启动一个新线程，会经历线程的各个生命周期，而如果直接调用run()方法，它就是个普通的run()方法，不会用子线程去调用，而直接用主线程执行的。

public static void main(String[] arg){    Runnable runnable = () -> {        System.out.println(Thread.currentThread().start());    };    runnable.run();    new Thread(runnable).start();}输出结果：mainThread-0

**start()执行过程：**1.检查线程状态。2.加入线程组。3.调用start0()发放启动线程。start()是被synchronized修饰的，可以保证线程安全。由JVM创建的main线程和system组线程，并不会通过start()来启动。

**注意：以上就是创建线程的方法，其中代码不保证可执行性，因为纯手打，有单子字母写错的可能。**

[32e080eb8d94295b970ee4fa1b8ec2a4.png]: /images/20221119/88779ae65aca4285adb57ad024e36a35.png