Java多线程Thread详细讲解（万字教程）二-阿里云开发者社区

Java如何开启线程？方式2：实现Runnable接口！（详细讲解）

这种方式的本质还是第一种，即Thread类实例调用start方法，从而去调用本地线程资源。因为有且仅有Thread类能通过start0()方法向操作系统申请线程资源（本地方法）！

JVM对于操作系统来说就是一个程序，是一个进程，JVM进程中可以有很多个线程，我们调用start方法其实就是去申请这个线程资源。

Runnable接口：

@FunctionalInterface
public interface Runnable {
    /**
     * When an object implementing interface <code>Runnable</code> is used
     * to create a thread, starting the thread causes the object's
     * <code>run</code> method to be called in that separately executing
     * thread.
     * <p>
     * The general contract of the method <code>run</code> is that it may
     * take any action whatsoever.
     *
     * @see     java.lang.Thread#run()
     */
    public abstract void run();
}

看上面的注释就知道怎么用了，当一个对象实现Runnable接口，你就去创建一个Thread，启动这个Thread，会导致run方法被调用。

我们按照官方的指导来做：

public class MyThread02 implements Runnable{
    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName() + "执行了！");
    }
    public static void main(String[] args) {
        new Thread(new MyThread02()).start();
    }
}

看到了吧，这种方式其实还是第一种。不同点在于，第一种方式是直接在Thread子类中重写的Run方法，而这种方式是你自己弄个类，里面有个run方法，传到Thread类中去，最后在Thread类启动的时候，会去调用那个类的run方法。换句话说，如果没有Thread类，这个Runnable实现类是没法自己跑起来的。

所有的秘密就在Thread类的构造函数里面。

public Thread(Runnable target) {
    init(null, target, "Thread-" + nextThreadNum(), 0);
}

调了init方法

private void init(ThreadGroup g, Runnable target, String name,long stackSize) {
    init(g, target, name, stackSize, null);
}

又是重载，继续找：

private void init(ThreadGroup g, Runnable target, String name,
                      long stackSize, AccessControlContext acc) {
    //省略其他代码...
    this.target = target;
}

原来，传入的Runnable对象是放到属性target中了。

/* What will be run. */
private Runnable target;

我们再看下Thread类中的run方法：

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

如果是方式1，这个run方法被重写了，启动start方法的时候就直接调用那个被重写后的run方法了。现在使用方式2的话，就还是调用Thread原生的run方法，做了一个中介，又去调用target的run方法，而target是我们自己传进去的，相当于把具体run的逻辑写到外部一个类里面去了。

以上就是第二种方式的原理，下面介绍一下如何简写代码？

比如，我们可以直接把Runnable实现类用匿名的方式new出来（少些一个类）：

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

因为Runnable接口只有一个抽象方法，所以还可以直接用Lamda表达式：

new Thread(() -> {
    System.out.println(Thread.currentThread().getName() + "执行了！");
}).start();

如果还不明白原理，可以看下这张图，安排的明明白白啦。

Java如何开启线程？方式3：用线程池Executor

什么是线程池： java.util.concurrent.Executors 提供了一个 java.util.concurrent.Executor 接口的实现用于创建线程池。

一个线程池包括以下四个基本组成部分：

1、线程池管理器（ThreadPool）：用于创建并管理线程池，包括创建线程池，销毁线程池，添加新任务；

2、工作线程（PoolWorker）：线程池中线程，在没有任务时处于等待状态，可以循环的执行任务；

3、任务接口（Task）：每个任务必须实现的接口，以供工作线程调度任务的执行，它主要规定了任务的入口，任务执行完后的收尾工作，任务的执行状态等；

4、任务队列（taskQueue）：用于存放没有处理的任务。提供一种缓冲机制。

线程池的作用：

线程池作用就是限制系统中执行线程的数量。

根据系统的环境情况，可以自动或手动设置线程数量，达到运行的最佳效果；少了浪费了系统资源，多了造成系统拥挤效率不高。用线程池控制线程数量，其他线程排队等候。一个任务执行完毕，再从队列的中取最前面的任务开始执行。若队列中没有等待进程，线程池的这一资源处于等待。当一个新任务需要运行时，如果线程池中有等待的工作线程，就可以开始运行了；否则进入等待队列。

为什么要用线程池:

1.减少了创建和销毁线程的次数，每个工作线程都可以被重复利用，可执行多个任务。

2.可以根据系统的承受能力，调整线程池中工作线线程的数目，防止因为消耗过多的内存，而把服务器累趴下(每个线程需要大约1MB内存，线程开的越多，消耗的内存也就越大，最后死机)。

Java里面线程池的顶级接口是Executor，但是严格意义上讲Executor并不是一个线程池，而只是一个执行线程的工具。真正的线程池接口是ExecutorService。

微信截图_20230504214123.png

要配置一个线程池是比较复杂的，尤其是对于线程池的原理不是很清楚的情况下，很有可能配置的线程池不是较优的，因此在Executors类里面提供了一些静态工厂，生成一些常用的线程池。

1. newSingleThreadExecutor

创建一个单线程的线程池。这个线程池只有一个线程在工作，也就是相当于单线程串行执行所有任务。如果这个唯一的线程因为异常结束，那么会有一个新的线程来替代它。此线程池保证所有任务的执行顺序按照任务的提交顺序执行。

2.newFixedThreadPool

创建固定大小的线程池。每次提交一个任务就创建一个线程，直到线程达到线程池的最大大小。线程池的大小一旦达到最大值就会保持不变，如果某个线程因为执行异常而结束，那么线程池会补充一个新线程。

3. newCachedThreadPool

创建一个可缓存的线程池。如果线程池的大小超过了处理任务所需要的线程，

那么就会回收部分空闲（60秒不执行任务）的线程，当任务数增加时，此线程池又可以智能的添加新线程来处理任务。此线程池不会对线程池大小做限制，线程池大小完全依赖于操作系统（或者说JVM）能够创建的最大线程大小。

4.newScheduledThreadPool

创建一个大小无限的线程池。此线程池支持定时以及周期性执行任务的需求。

为了方便演示，我们就创建只有一个线程的线程池：

package com.javaxbfs.thread;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;
public class MyThread03 implements Runnable{
    public static void main(String[] args) throws InterruptedException {
        //创建线程池
        ExecutorService executorService = Executors.newSingleThreadExecutor();
        //提交线程任务-Runnable对象
        Future<?> future = executorService.submit(new MyThread03());
        while(!future.isDone()){
           Thread.sleep(200);
        }
        // 关闭线程池
        executorService.shutdown();
        System.out.println("线程池关闭");
    }
    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName() + "========>正在执行！");
        try {
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(Thread.currentThread().getName() + "========>执行成功！");
    }
}

效果：

pool-1-thread-1========>正在执行！
pool-1-thread-1========>执行成功！
线程池关闭

这边我们使用的是Runnable对象，线程池还可以接受Callable对象。

package com.javaxbfs.thread;
import java.util.concurrent.*;
public class MyThread04 implements Callable {
    public static void main(String[] args) throws InterruptedException, ExecutionException {
        //创建线程池
        ExecutorService executorService = Executors.newSingleThreadExecutor();
        //提交线程任务-Runnable对象
        Future<String> future = executorService.submit(new MyThread04());
        while(!future.isDone()){
           Thread.sleep(200);
        }
        String result = future.get();
        System.out.println("这里拿到线程任务的返回值：" + result);
        // 关闭线程池
        executorService.shutdown();
        System.out.println("线程池关闭");
    }
    @Override
    public String call() {
        System.out.println(Thread.currentThread().getName() + "========>正在执行！");
        try {
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(Thread.currentThread().getName() + "========>执行成功！");
        return "SUCCESS";
    }
}

效果：

pool-1-thread-1========>正在执行！
pool-1-thread-1========>执行成功！
这里拿到线程任务的返回值：SUCCESS
线程池关闭

两种方式我都写了例子，关于这个后面还会细说。

总结

1. 不管你是用上面介绍的三种方法的哪一种，都绕不开Thread类，因为只有Thread类的start方法可以去申请本地线程资源！

2. 用Runnable可以把任务代码写在Thread类外面，降低耦合度，更加灵活。

3.Callable一般配合线程池使用，重写的call方法可以添加返回值。

4.线程执行入口永远是Thread类的run方法，这个run方法要么被你重写，要么调用target的run方法，target就是实现runnable接口的对象。

封装Thread类的start方法（经典技巧）

Thread类的start方法是去请求本地资源的，很多源码喜欢把这个细节封装掉，现在让我们来模仿一下这种技巧。

package com.javaxbfs.thread;
public class MyThread05 implements Runnable{
    public void begin(){
        new Thread(this).start();
    }
    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName() + "执行了！");
    }
    public static void main(String[] args) {
        MyThread05 myThread05 = new MyThread05();
        myThread05.begin();
    }
}

思路特别简单，不需要你手动去new Thread类了，而是直接在Runnable类中添加begin方法，把这个事情给做了。

Java多线程Thread详细讲解（万字教程）二

Java如何开启线程？方式2：实现Runnable接口！（详细讲解）

Java如何开启线程？方式3：用线程池Executor

封装Thread类的start方法（经典技巧）

热门文章

最新文章

相关课程

相关电子书

相关实验场景

Java多线程Thread详细讲解（万字教程）二

Java如何开启线程？ 方式2：实现Runnable接口！（详细讲解）

Java如何开启线程？ 方式3：用线程池Executor

封装Thread类的start方法（经典技巧）

热门文章

最新文章

相关课程

相关电子书

相关实验场景

Java如何开启线程？方式2：实现Runnable接口！（详细讲解）

Java如何开启线程？方式3：用线程池Executor