多线程启动的几种方式

1.继承thread类

public class Mythread extends Thread {
    @Override
    public void run(){
        System.out.println("1.继承Thread，启动调用start方法启动线程");
    }
}

2.实现runnable接口

public class MythreadRunable implements Runnable {
    @Override
    public void run(){
        System.out.println("2.实现runnable接口，再 new Thread(new MythreadRunable()).start()来启动线程");
    }
}

3.匿名内部类方式

         new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("3.我是通过匿名内部类方式启动的线程");
            }
        }).start();

或者

         new Thread() {
            @Override
            public void run() {
                System.out.println("巧了，我也是通过匿名内部类方式启动的线程");
            }
        }.start();

4.使用线程池方式启动.

(这里调用java并发包下的执行器类的静态的“新建固定的线程池”方法创建指定的线程池的数量)

       ExecutorService pool= Executors.newFixedThreadPool(1);
       pool.execute(new Runnable() {
           @Override
           public void run() {
               System.out.println("4.我是通过线程池（调执行器的静态方法）方式启动的线程");
           }
       });
       pool.shutdown();

5.实现Callable接口启动线程

知识补充：

通过Thread类和Runnable接口可以启动线程，但Thread类和Runnable接口都不允许声明检查型异常，也不能定义返回值。

jdk1.5中，Callable接口（产生结果,可回调的接口）和Future接口（拿到结果,Future 表示异步计算的结果）的引入以及他们对线程池的支持优雅地解决了这两个问题

不管用哪种方式创建线程，其本质都是Callable接口与Runable接口。两者都是可被其它线程执行的任务！！区别是：

（1）Callable规定的方法是call()，而Runnable规定的方法是run()。

（2）Callable的任务执行后可返回值，而Runnable的任务是不能返回值的。

（3）call()方法可抛出异常，而run()方法是不能抛出异常的。

（4）运行Callable任务可拿到一个Future对象。

 FutureTask<String> futureTask=new FutureTask<String>(new Callable<String>() {
            @Override
            public String call() throws Exception {
                return "5.我是通过实现Callable（）方法启动的线程，通过futureTask.get()方法得到的string";
            }
        });
        new Thread(futureTask).start();
        try {
            System.out.println(futureTask.get());
        } catch (Exception e) {}

综合测试方法如下：

import java.util.concurrent.*;

public class MainTest {
    public static void main(String arg[]){
        //1.继承thread类
        Mythread mythread=new Mythread();
        mythread.start();

        //2.实现runnable接口
        MythreadRunable mythreadRunable=new MythreadRunable();
        new Thread(mythreadRunable).start();

        //3.匿名内部类
        new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("3.我是通过匿名内部类方式启动的线程");
            }
        }).start();

        //4.使用线程池方式启动.(这里调用java并发包下的执行器类的静态的“新建固定的线程池”方法创建指定的线程池的数量)
        ExecutorService pool= Executors.newFixedThreadPool(1);
        pool.execute(new Runnable() {
            @Override
            public void run() {
                System.out.println("4.我是通过线程池（调执行器的静态方法）方式启动的线程");
            }
        });
        pool.shutdown();

        //5.实现Callable接口，可以返回结果（）
        FutureTask<String> futureTask=new FutureTask<String>(new Callable<String>() {
            @Override
            public String call() throws Exception {
                return "5.我是通过实现Callable（）方法启动的线程，通过futureTask.get()方法得到的string";
            }
        });
        new Thread(futureTask).start();
        try {
            System.out.println(futureTask.get());
        } catch (Exception e) {}
    }
}

##测试结果：

##参考文章：
1.https://blog.51cto.com/10553553/2065549?from=timeline
2.https://www.cnblogs.com/felixzh/p/6044371.html