Java多线程实现的四种方式

前面两种可以归结为一类：无返回值，原因很简单，通过重写run方法，run方式的返回值是void，所以没有办法返回结果
后面两种可以归结成一类：有返回值，通过Callable接口，就要实现call方法，这个方法的返回值是Object，所以返回的结果可以放在Object对象中

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

继承Thread类，重写run方法，通过子类构造方法来入参
无返回值

import java.time.LocalDateTime;

/**
 * @author administrator
 * @date 2020-05-12 20:29
 */
public class MyThreadImpl01 extends Thread {

    private String title;

    public MyThreadImpl01(String title) {
        this.title = title;
    }

    @Override
    public void run() {
        //自己的线程处理逻辑代码
        System.out.println(this.title + "运行:" + LocalDateTime.now());
    }

    //测试
    public static void main(String[] args) {
        new MyThreadImpl01("线程A").start();
        new MyThreadImpl01("线程B").start();
        new MyThreadImpl01("线程C").start();
    }

}

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

实现Runnable接口，实现run方法；
实现类的实例作为Thread构造函数的入参，通过调用Thread的start()方法启动线程；
无返回值

import java.time.LocalDateTime;

/**
 * @author administrator
 * @date 2020-05-12 20:29
 */
public class MyThreadImpl02 implements Runnable {

    private String title;

    public MyThreadImpl02(String title) {
        this.title = title;
    }
    
    @Override
    public void run() {
        //自己的线程处理逻辑代码
        System.out.println(this.title + "运行:" + LocalDateTime.now());
    }

    //测试
    public static void main(String[] args) {
        new Thread(new MyThreadImpl02("线程A")).start();
        new Thread(new MyThreadImpl02("线程B")).start();
        new Thread(new MyThreadImpl02("线程C")).start();
    }
}

3、通过Callable和FutureTask创建线程

1、实现Callable(V)接口 ，并实现Call方法 ；
2、创建Callable实现类的实现，使用FutureTask类包装Callable对象(该FutureTask对象封装了Callable对象的Call方法的返回值 )；
3、使用FutureTask对象作为Thread对象的构造方法入参，创建并启动线程 ；
4、调用FutureTask对象的get()来获取子线程执行结束的返回值；
有返回值

import java.time.LocalDateTime;
import java.util.concurrent.Callable;
import java.util.concurrent.FutureTask;

/**
 * @author administrator
 * @date 2020-05-12 20:29
 */
public class MyThreadImpl03 implements Callable<String> {

    private String title;

    public MyThreadImpl03(String title) {
        this.title = title;
    }

    @Override
    public String call() throws Exception {
        //自己的线程处理逻辑代码
        System.out.println(this.title + "运行:" + LocalDateTime.now());
        return this.title + "执行完毕!";
    }

    //测试
    public static void main(String[] args) throws Exception {
        FutureTask futureTask1 = new FutureTask(new MyThreadImpl03("线程A"));
        FutureTask futureTask2 = new FutureTask(new MyThreadImpl03("线程B"));
        FutureTask futureTask3 = new FutureTask(new MyThreadImpl03("线程C"));

        new Thread(futureTask1).start();
        new Thread(futureTask2).start();
        new Thread(futureTask3).start();

        System.out.println("线程A返回：" + futureTask1.get());
        System.out.println("线程B返回：" + futureTask2.get());
        System.out.println("线程C返回：" + futureTask3.get());

    }
}

执行Callable任务后，可以获取一个Future的对象，在该对象上调用get就可以获取到Callable任务返回的对象了。get方法是阻塞的，如果线程无返回结果，get方法会一直等待。

4、通过线程池创建线程

本文以Executors举例说明，在实际当中不建议使用Executors，而是直接使用ThreadPoolExecutor来创建线程池；
有返回值

import java.time.LocalDateTime;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

/**
 * @author administrator
 * @date 2020-05-12 20:29
 */
public class MyThreadImpl04 implements Runnable {

    private static int POOL_NUM = 5;     //线程池数量

    private String title;

    public MyThreadImpl04(String title) {
        this.title = title;
    }

    @Override
    public void run() {
        //自己的线程处理逻辑代码
        System.out.println(this.title + "运行:" + LocalDateTime.now());
    }

    //测试
    public static void main(String[] args) throws Exception {
        ExecutorService executorService = null;
        try {
            executorService = Executors.newFixedThreadPool(5);
            for (int i = 1; i <= POOL_NUM; i++) {
                MyThreadImpl04 thread = new MyThreadImpl04("线程" + i);
                //Thread.sleep(1000);
                executorService.execute(thread);
            }
        } catch (Exception e) {
            throw e;
        } finally {
            //关闭线程池
            if (null != executorService) {
                executorService.shutdown();
            }
        }

    }
    
}

ExecutoreService提供了submit()方法，传递一个Callable或Runnable，返回Future；
如果Executor后台线程池还没有完成Callable的计算，Future对象的get()方法，会阻塞直到计算完成；

Executors类：提供了一系列工厂方法用于创建线程池，返回的线程池都实现了ExecutorService接口

• public static ExecutorService newFixedThreadPool(int nThreads)
  创建一个定长线程池，可控制线程最大并发数，超出的线程会在队列中等待。
• public static ExecutorService newCachedThreadPool()
  创建一个可缓存线程池，如果线程池长度超过处理需要，可灵活回收空闲线程，若无可回收，则新建线程。
• public static ExecutorService newSingleThreadExecutor()
  创建一个单线程化的线程池，它只会用唯一的工作线程来执行任务，保证所有任务按照指定顺序(FIFO, LIFO, 优先级)执行;
• public static ScheduledExecutorService newScheduledThreadPool(int
  corePoolSize)
  创建一个定长线程池，支持定时及周期性任务执行，多数情况下可用来替代Timer类。