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

多线程核心知识总结

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

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

官方文档中，只有两种。

声明一个Thread的子类

public class ThreadStyle extends Thread{
   

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

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

声明一个实现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方法更好
理由如下：

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

两种方法的本质对比

实现Runnable——最终调用target.run()
继承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方法。

总结：

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

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

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

3.典型错误观点

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

/** 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()是一样的

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

/** * 描述： 定时器创建线程 */
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);
    }
}