多线程的实现方式

在外面面试过程中，往往避免不了这个问题：请你说出创建多线程有多少种方式，而多线程也是我们日常开发中要经常使用的。所以，学会多线程是每个程序员都要走过的必经之路。

下面我们来看列举出多线程有哪几种的实现方式以及其优缺点。

1、继承Thread类，重写run方法

具体步骤是：

（1）定义 Thread 类的子类，并重写该类的 run 方法，该 run 方法的方法体
就代表了线程要完成的任务。因此把 run()方法称为执行体。
（2）创建 Thread 子类的实例，即创建了线程对象。
（3）调用线程对象的 start()方法来启动该线程。

下面用代码来示范一下

public class MyThread extends Thread{
    @Override
    public void run(){
        System.out.println(super.getName()+"Started");
    }
}

运行一下

 Thread t1 = new MyThread();
        Thread t2 = new MyThread();
        t1.run();
        t2.start();
        //让主线程沉睡
        Thread.sleep(1000);

这就完成线程的创建了。

ps:这里说一下start方法和run方法的区别，run方法只是一个普通的方法，当线程调用start方法之后，它会去执行线程的run方法，但是它执行不是按照顺序执行的，而是会多个调用start的线程去抢占cpu的资源，抢占到了之后才会执行。

而当你调用run这个普通方法时会按照代码的顺序结构去执行调用，而不是以多线程的方式去执行。所以，启动线程一定要调用start方法而不是run方法。

使用继承Thread类的方式创建多线程时的优势是： 编写简单，如果需要访问当前线程，则无需使用Thread.currentThread（）方法，直接使用this即可获得当前线程。

劣势是：线程类已经继承了 Thread 类，所以不能再继承其他父类。

2、实现Runnable接口，重写run方法。

具体步骤：

（1）定义 runnable 接口的实现类，并重写该接口的 run()方法，该 run()方法
的方法体同样是该线程的线程执行体。
（2）创建 Runnable 实现类的实例，并依此实例作为 Thread 的 target 来创
建 Thread 对象，该 Thread 对象才是真正的线程对象。
（3）调用线程对象的 start()方法来启动该线程。

Runnable跟Thread有个不同的地方是它可以进行一个变量的共享，多个线程共同操作这个变量。

public class MyRunnable implements Runnable {
    
    private int num = 10;
    
    @Override
    public  void run() {
        num--;
        System.out.println(Thread.currentThread().getName()+":"+num);
    }
}

创建线程运行

        Runnable runnable = new MyRunnable();
        new Thread(runnable).start();
        new Thread(runnable).start();
        //让主线程沉睡
        Thread.sleep(1000);

可以看到，两个线程都对num进行了自减操作，最后得到num的数值为8，证明了两个线程所操作的num是同一个变量。那我们怎么样才能让它们有独立的num呢？

如果我们在创建线程时用两个Runnable进行创建，我们看看结果如何。

        Runnable runnable1 = new MyRunnable();
        Runnable runnable2 = new MyRunnable();
        new Thread(runnable1).start();
        new Thread(runnable2).start();
        //让主线程沉睡
        Thread.sleep(1000);

可以看到，两个线程的num都是9，证明了这个变量他们是独立享有的。

实现Runnable接口的方式优点是：

在这种方式下，多个线程可以共享同一个 target 对象，所以非常适合多个相
同线程来处理同一份资源的情况，从而可以将 CPU、代码和数据分开，形成清晰
的模型，较好地体现了面向对象的思想。

劣 势 是 ：

编 程 稍 微 复 杂 ， 如 果 要 访 问 当 前 线 程 ， 则 必 须 使 用
Thread.currentThread()方法。

3、实现Callable接口，重写call方法。

具体步骤：

（1）创建 Callable 接口的实现类，并实现 call()方法，该 call()方法将作为线
程执行体，并且有返回值。
（2）创建 Callable 实现类的实例，使用 FutureTask 类来包装 Callable 对象，
该 FutureTask 对象封装了该 Callable 对象的 call()方法的返回值。
（3）使用 FutureTask 对象作为 Thread 对象的 target 创建并启动新线程。
（4）调用 FutureTask 对象的 get()方法来获得子线程执行结束后的返回值

使用Callable相对于Runnable最大的不同点在于使用Callable创建的线程有返回值，而且允许抛出异常。

代码如下：

public class MyCallable implements Callable {
    private int num = 10;

    @Override
    public Object call() throws Exception {
        System.out.println(Thread.currentThread().getName()+":"+num);
        num--;
        return num;
    }
}

启动方式也跟前面不一样，不再使用Thread类，而是使用FutureTask类。

        Callable<Integer> callable = new MyCallable();
        FutureTask<Integer> task1 = new FutureTask<Integer>(callable);
        FutureTask<Integer> task2 = new FutureTask<Integer>(callable);
        new Thread(task1).start();
        new Thread(task2).start();
        Integer num1 = task1.get();
        Integer num2 = task2.get();
        System.out.println(num1);
        System.out.println(num2);

可以看到，我们拿到了线程的返回值num，而且两个线程共享同一个变量。

如果想独立享有变量方法如同上面，使用不同的callable对象创建线程。

ps：这里要注意一下FutureTask对象的get方法是阻塞的而不是立即返回的，当线程任务执行完之后才会给返回值。

使用Callable接口拥有了Runnable方法的优点，还可以有返回值，允许抛出异常，但是代码量也多了一点。

4、使用线程池的方式

使用线程池的方式跟前面三种有点不太一样，前面三种强调的是任务的类，就是你要用线程去干什么，然后去创建不同的线程。

而是用线程池是我们先开辟一下线程把它保存起来，当你需要用到新线程就从刚才保存的地方去拿一个使用，当你用完了之后就把这个线程还回来。

这样每次我们需要用到线程的时候就减少了创建新线程的时间，重复利用线程池中的线程，降低资源消耗。

可以使用Callable或者Runnable作为线程的人物类。下面我们用newFixedThreadPool来作示范

newFixedThreadPool：创建一个固定长度的线程池，每当提交一个任务就创建一个线程，直到达 到线程池的最大数量，这时线程规模将不再变化，当线程发生未预期的错误而 结束时，线程池会补充一个新的线程

        ExecutorService pool = Executors.newFixedThreadPool(3);
        MyRunnable runnable = new MyRunnable();
        pool.submit(runnable);
        Callable<Integer> callable = new MyCallable();
        Future<Integer> future = pool.submit(callable);
        System.out.println(future.get());
        //关闭线程
        pool.shutdown();

如果我们需要多次调用线程的话看看是什么效果

        ExecutorService pool = Executors.newFixedThreadPool(3);
        MyRunnable runnable = new MyRunnable();
        pool.submit(runnable);
        pool.submit(runnable);
        pool.submit(runnable);
        pool.submit(runnable);
        pool.submit(runnable);
        pool.submit(runnable);
        pool.shutdown();

可以看到我们的线程始终就是3个，因为我们设置了同时最多能有三个线程去运行。

下面是几种常见的创建线程池类型

newFixedThreadPool(int nThreads)

创建一个固定长度的线程池，每当提交一个任务就创建一个线程，直到达
到线程池的最大数量，这时线程规模将不再变化，当线程发生未预期的错误而
结束时，线程池会补充一个新的线程

newCachedThreadPool()

创建一个可缓存的线程池，如果线程池的规模超过了处理需求，将自动回收
空闲线程，而当需求增加时，则可以自动添加新线程，线程池的规模不存在任何
限制

newSingleThreadExecutor()

这是一个单线程的 Executor，它创建单个工作线程来执行任务，如果这个线
程异常结束，会创建一个新的来替代它；它的特点是能确保依照任务在队列中的
顺序来串行执行

newScheduledThreadPool(int corePoolSize)

创建了一个固定长度的线程池，而且以延迟或定时的方式来执行任务，类似
于 Timer。

总结

实现多线程的几种方式

1、继承Thread类，重写run方法
2、实现Runnable接口，重写run方法。【可以避免由于Java的单继承特性而带来的局限。适合多个线程去处理同一资源的情况】
3、实现Callable接口，重写call方法。【有返回值，允许抛出异常】
4、使用线程池【减少创建新线程的时间，重复利用线程池中线程，降低资源消耗，可有返回值】