1.2.启动线程的五类种方法

一.new MyThread().start()

继承Thread类创建线程类

1. 定义一个继承Thread类的子类，并重写该类的run()方法

2. 创建Thread子类的实例，即创建了线程对象

3. 调用该线程对象的start()方法启动线程

二.new Thread(r).start()

实现Runnable接口创建线程类

1. 定义Runnable接口的实现类，并重写该接口的run()方法

2. 创建Runnable实现类的实例，并以此实例作为Thread的target对象，即该Thread对象才是真正的线程对象

注意：

在java的体系中，方法一较方法二来说是更好的。因为一个子类只能继承一个父类，但是却可以实现多个接口。

三.直观变形

• 匿名内部类创建 Thread 子类对象。

Thread thread1 = new Thread(){
    @Override
    public void run() {
        System.out.println("使用匿名类创建 Thread 子类对象");
    }
};

• 匿名内部类创 Runnable 子类对象。

Thread thread2 = new Thread(new Runnable() {
    @Override
    public void run() {
        System.out.println("使用匿名类创建 Runnable 子类对象");
    }
});

• lambda 表达式创建 Runnable 子类对象。

Thread thread3 = new Thread(()-> {
    System.out.println("使用匿名类创建 Thread 子类对象");
});

四.线程池

参见：

java线程池和多线程的使用详解_java使用线程池启动多线程-CSDN博客

可以重点关注其中的“Java线程池的使用”、“线程和线程池的使用规范”以及对应的策略。

五.Future Callable and FutureTask

1.Callable + FutureTask

Callable和Runnable的格式是类似的。

实现Callable的call 方法；

创建一个FutureTask ，用来接收callable的返回；

在主线程中调用 futureTask.get() ，能够阻塞等待(因为自带t.join)新线程计算完毕. 并获取到 FutureTask中的结果

package com.pavin.thread;
​
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;
​
public class CallableTest {
​
    public static class MyCallable implements Callable<Integer> {
​
        @Override
        public Integer call() throws Exception {
            int sum = 0;
            for(int i = 0; i < 100; i++) {
                sum += i;
            }
            return sum;
        }
    }
​
​
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        MyCallable callable = new MyCallable();
​
        FutureTask<Integer> futureTask = new FutureTask<>(callable);
        Thread t = new Thread(futureTask);
        t.start();
​
        Integer result = futureTask.get();
        System.out.println(result);
    }
}

输出结果：4950

2.Callable + Future

package com.pavin.thread;
​
import java.util.concurrent.*;
​
public class CallableThreadTest {
​
    public static class MyCallable implements Callable<Integer> {
​
        @Override
        public Integer call() throws Exception {
            int sum = 0;
            for(int i = 0; i < 100; i++) {
                sum += i;
            }
            return sum;
        }
    }
​
​
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        ExecutorService service = Executors.newCachedThreadPool();
        Future<Integer> future = service.submit(new MyCallable());
​
        Integer result = future.get();
        System.out.println(result);
        service.shutdown();
    }
}

输出结果：4950