2、创建线程的方式

方式一、继承Thread类

public class MyThread extends Thread {
    //执行体 线程要完成的任务
    @Override
    public void run() {
        System.out.println("执行MyThread类中run方法的线程名:" +     
            Thread.currentThread().getName());
    }
}

public class Run {
    public static void main(String[] args) {
        //创建Thread子类的实例，即创建了线程对象
        MyThread myThread = new MyThread();
        myThread.setName("A");
        //调用线程对象的start()方法来启动该线程
        myThread.start();
        System.out.println("over");
    }
}

运行结果：

over
执行MyThread类中run方法的线程名A

tips: 从输出结果可以看出，在使用多线程技术的时候，输出结果与代码的执行顺序或调用顺序无关。

方式二、实现Runnable接口

package com.demo;
//定义runnable接口的实现类，并重写该接口的run()方法，该run()方法的方法体同样是该线程的线程执行体
public class MyThread implements Runnable{
    @Override
    public void run() {
        System.out.println("执行MyThread中run方法的线程名称：" +     Thread.currentThread().getName());
    }
}

package com.demo;

public class Run {
    public static void main(String[] args) {
        //创建 Runnable实现类的实例
        MyThread myThread = new MyThread();
        //以此实例作为Thread的target来创建Thread对象，该Thread对象才是真正的线程对象
        Thread t1 = new Thread(myThread);
        t1.setName("t1");
        //Thread t1 = new Thread(myThread,"t1");
        //调用线程对象的start()方法来启动该线程
        t1.start();
    }
}

运行结果：

执行MyThread中run方法的线程名称：t1

方式三、通过Callable和Future创建线程

package com.demo2;

import java.util.concurrent.Callable;
//创建Callable接口的实现类，并实现call()方法，该call()方法将作为线程执行体，并且有返回值
public class MyCallableThread implements Callable<String> {
    @Override
    public String call() throws Exception {
        String name = Thread.currentThread().getName();
        System.out.println("调用call方法的线程名称：" + name);
        return name;
    }
}

package com.demo2;

import java.util.concurrent.ExecutionException;
import java.util.concurrent.Future;
import java.util.concurrent.FutureTask;

public class Run {
    public static void main(String[] args) {
        try {
            //创建Callable实现类的实例
            MyCallableThread myCallableThread = new MyCallableThread();
            //使用FutureTask类来包装Callable对象，该FutureTask对象封装了该Callable对象的call()方法的返回值
            //FutureTask是一个包装器，它通过接受Callable来创建，它同时实现了Future和Runnable接口
            FutureTask<String> futureTask = new FutureTask<>(myCallableThread);
            //使用FutureTask对象作为Thread对象的target创建并启动新线程
            Thread thread = new Thread(futureTask);
            thread.setName("t1");
            thread.start();
            System.out.println("futureTask获取callable的返回值：" + futureTask.get());
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }
    }
}

运行结果：

调用call方法的线程名称：t1
futureTask获取callable的返回值：t1

对FutureTask是一个包装器，它通过接受Callable来创建，它同时实现了Future和Runnable接口作出解释

FutureTask implements RunnableFuture<V>接口 , RunnableFuture<V> extends Runnable, Future<V>

FutureTask实际上也就是Runnable接口的子孙，将其作为target对象供Thread类实例化线程的时候调用，调用之后，启动线程，执行FutureTask类中的run()方法，在run()方法中调用callable对象的call()，并获取了返回值。

public class FutureTask<V> implements RunnableFuture<V> {
    /*
        ...
    */
    //构造器传入callable
    public FutureTask(Callable<V> callable) {
        if (callable == null)
            throw new NullPointerException();
        this.callable = callable;
        this.state = NEW;       // ensure visibility of callable
    }
    
    //重写RunnableFuture中的run()
    public void run() {
        if (state != NEW ||
            !UNSAFE.compareAndSwapObject(this, runnerOffset,
                                         null, Thread.currentThread()))
            return;
        try {
            Callable<V> c = callable;
            if (c != null && state == NEW) {
                V result;
                boolean ran;
                try {
                    //调用callable中的call()
                    result = c.call();
                    ran = true;
                } catch (Throwable ex) {
                    result = null;
                    ran = false;
                    setException(ex);
                }
                if (ran)
                    set(result);
            }
        } finally {
            // runner must be non-null until state is settled to
            // prevent concurrent calls to run()
            runner = null;
            // state must be re-read after nulling runner to prevent
            // leaked interrupts
            int s = state;
            if (s >= INTERRUPTING)
                handlePossibleCancellationInterrupt(s);
        }
    }
}

public interface RunnableFuture<V> extends Runnable, Future<V> {
    /**
     * Sets this Future to the result of its computation
     * unless it has been cancelled.
     */
    void run();
}

创建线程的三种方式的对比

采用实现Runnable、Callable接口的方式创建多线程

优势：

线程类只是实现了Runnable接口或Callable接口，还可以继承其他类。

在这种方式下，多个线程可以共享同一个target对象，所以非常适合多个相同线程来处理同一份资源的情况，从而可以将CPU、代码和数据分开，形成清晰的模型，较好地体现了面向对象的思想。

劣势：

编程稍微复杂，如果要访问当前线程，则必须使用Thread.currentThread()方法。

使用继承Thread类的方式创建多线程

优势：

编写简单，如果需要访问当前线程，则无需使用Thread.currentThread()方法，直接使用this即可获得当前线程。

劣势：

线程类已经继承了Thread类，所以不能再继承其他父类。

Runnable和Callable的区别

Callable规定（重写）的方法是call()，Runnable规定（重写）的方法是run()。
Callable的任务执行后可返回值，而Runnable的任务是不能返回值的。
call方法可以抛出异常，run方法不可以。
运行Callable任务可以拿到一个Future对象，表示异步计算的结果。它提供了检查计算是否完成的方法，以等待计算的完成，并检索计算的结果。通过Future对象可以了解任务执行情况，可取消任务的执行，还可获取执行结果。