小编点评

继承Thread类和实现Runnable接口是创建线程的两种方式。继承Thread类可以实现多继承，但限制了只能有一个父类，而实现Runnable接口可以实现多个接口，具有更大的灵活性。在具体应用中，可以根据需求选择合适的方式。 如果需要获得线程执行结果，可以选择实现Callable接口的方式。Callable接口可以声明线程执行的结果类型，并重写call方法来返回执行结果。使用FutureTask将线程任务包装成未来任务对象，然后将其作为线程对象运行，这样可以在线程执行完成后获取结果。

正文

一、继承Thread类

1. 定义一个类继承线程类Thread
2. 重写run()方法
3. 创建线程对象
4. 调用线程对象的start()方法创建线程

Thread类的常用API

• setName(String name)：给线程取名字
• getName()：获取线程的名字
• public static Thread currentThread()：获取当前线程对象，这个代码在哪个线程中就获取哪个线程对象
• public static void sleep(long time)：让当前线程休眠多少毫秒再继续执行

优点：

• 编码简单

缺点：

• 线程类已经继承Thread就无法继承其他类了，功能无法通过继承拓展（单继承的局限性）

二、实现Runable接口

1. 定义一个线程任务类实现Runable接口
2. 重写run()方法
3. 创建线程任务对象
4. 把线程任务对象包装成线程对象
5. 调用线程对象的start()方法启动线程

class MyRunable implements Runnable{

    @Override
    public void run() {
        System.out.println("hello runable");
    }
}

public static void main(String[] args) {
    MyRunable target = new MyRunable();
    Thread t = new Thread(target);
    t.start();
}

优点：

• 避免了Java单继承的局限性
• 同一个任务对象可以被包装成多个线程对象
• 适合多个线程去共享同一个资源
• 实现解耦，线程任务代码可以被多个线程共享，线程任务代码和线程独立
• 线程池只能放入实现Runable和Callable接口的线程任务，不能直接放入继承Thread类的线程对象

缺点

• 编码复杂（其实还好啦）

匿名内部类的写法：

Runnable target = new Runnable() {
    @Override
    public void run() {
        System.out.println("匿名内部类写法");
    }
};
Thread t = new Thread(target);
t.start();

//简化
new Thread(new Runnable() {
    @Override
    public void run() {
        System.out.println("匿名内部类写法");
    }
}).start();

//再简化
new Thread(() -> System.out.println("匿名内部类写法")).start();

三、实现Callable接口

1. 定义一个线程任务类实现Callable接口，申明线程执行的结果类型
2. 重写线程任务类的call方法，这个方法可以直接返回执行结果
3. 创建一个Callable的线程任务对象
4. 把线程任务对象包装成一个未来任务对象
5. 把未来任务对象包装成线程对象
6. 调用start()方法启动线程

//1.定义一个线程任务类实现Callable接口，申明线程执行的结果类型
class MyCallable implements Callable<String>{

    //2.重写线程任务类的call方法，这个方法可以直接返回执行结果
    @Override
    public String call() throws Exception {
        System.out.println("hello callable");
        return "success";
    }
}

//3.创建一个Callable的线程任务对象
Callable<String> call = new MyCallable();
//4.把线程任务对象包装成一个未来任务对象
//-- 未来任务对象其实就是一个Runable对象，这样就可以被包装成线程对象
//-- 未来任务对象可以在线程执行完毕后得到线程执行结果
FutureTask<String> future = new FutureTask<>(call);

//5.把未来任务对象包装成线程对象
Thread t = new Thread(future);
t.start();

//获取线程执行结果，如果线程还没执行完，让出CPU等线程执行完再来去结果
try {
    String res = future.get();
    System.out.println(res);
} catch (InterruptedException e) {
    e.printStackTrace();
} catch (ExecutionException e) {
    e.printStackTrace();
}

优点：

• 拥有所有Runable的优点
• 能直接得到线程执行的结果

缺点：

• 编码复杂