多线程核心知识总结（一）——实现多线程的正确姿势

多线程核心知识总结

一.实现多线程的正确姿势

1.实现多线程的方法到底有几种？

官方文档中，只有两种。

1. 声明一个Thread的子类

public class ThreadStyle extends Thread{

    @Override
    public void run() {
        System.out.println("用Thread类实现线程");
    }

    public static void main(String[] args) {
        new ThreadStyle().start();
    }
}

2. 声明一个实现Runnable接口的类

public class RunnableStyle implements Runnable{

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

    @Override
    public void run() {
        System.out.println("用Runnable方法实现线程");
    }
}

两种方法的对比
实现Runnable方法更好
理由如下：

1. 从代码架构的角度考虑，具体执行的任务，也就是run方法代码里的内容，应该和线程的创建，运行机制，也就是Thread类，应该是解耦的。
2. 如果用Thread类，每次想执行一个任务，只能新建一个线程，而新建一个独立线程的损耗是比较大的（创建，执行，销毁），而如果使用Runnable,就可以使用线程池之类的工具，这样可以大大减小损耗。
3. 继承Thread类之后，由于java不支持双继承，导致这个类无法继承其他类，大大限制了可扩展性。

两种方法的本质对比

1. 实现Runnable——最终调用target.run()
2. 继承Thread——重写整个run（）方法

2.同时使用两种方法：正确实现方法的总结

public class BothRunnableThread {

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

运行这段代码结果为

我来自Thread

从面向对象的角度考虑
Thread中的run方法完全覆盖掉了Runnable中的run方法，所以执行的是已经覆盖方法，即为Thread里的run方法。

总结：

1. 实现线程通常可以分为两类

2. 准确的讲，创建线程只有一种方式，就是构造Thread类，而实现线程的执行单元有两种形式。

   1. 实现Runnable接口的run方法，并把Runnable实例传给Thread类
   2. 重写Thread的run方法（继承Thread类）

3.典型错误观点

1. 线程池创建线程也是一种新的创建线程的方式

/**
 1. 描述：     线程池创建线程的方法
 */
public class ThreadPool{

    public static void main(String[] args) {
        ExecutorService executorService = Executors.newCachedThreadPool();
        for (int i = 0; i < 1000; 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());
    }
}

线程池创建线程的本质和new Thread()是一样的

2. 通过Callable和FutureTask创建线程，也算是一种新的创建线程方式
   根据类的实现图，可以看出本质上都是runnable和thread实现的

3. 定时器

/**
 * 描述：     定时器创建线程
 */
public class DemoTimmerTask {

    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);
    }
}

查看源码，本质都是一种包装

4.常见的面试问题

有多少种实现线程的方法，思路有5点

1. 从不同角度看，会有不同的答案
2. 经典答案是两种（Thread,Runnable）
3. 看原理，两种本质是一样的(构造Thread类）
4. 具体展开说其他方式（线程池，定时器，匿名内部类，Lambda表达式）
5. 结论